{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\n_sum = 0\\n#这里的Y[0] * Y[0]其实没有必要,因为一定是1\\n_sum += Y[0] * Y[0] * K(X[0], X[0]) * alpha[0] * alpha[0] / 2\\n#这里的Y[1] * Y[1]其实没有必要,因为一定是1\\n_sum += Y[1] * Y[1] * K(X[1], X[1]) * alpha[1] * alpha[1] / 2\\n_sum += Y[0] * Y[1] * K(X[0], X[1]) * alpha[0] * alpha[1] - alpha[0] - alpha[1]\\n\\ns1 = 0\\nfor i in range(2, N):\\n    s1 += Y[i] * alpha[i] * K(X[i], X[0])\\n\\ns2 = 0\\nfor i in range(2, N):\\n    s2 += Y[i] * alpha[i] * K(X[i], X[1])\\n\\n_sum += Y[0] * alpha[0] * s1\\n_sum += Y[1] * alpha[1] * s1\\n_sum'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#============软间隔支持向量机============\n",
    "#约束条件是\n",
    "#y * (w * x + b) >= 1 - xi\n",
    "#因为是软间隔,所以不可能所有的点都满足>=1的约束,所以引入了松弛变量xi\n",
    "\n",
    "#优化目标函数是\n",
    "#最小化 -> w平方后求和再开方(2范数)/2 + C*(xi求和)\n",
    "#这里C>0,称为惩罚参数\n",
    "#优化目标函数包含两层含义,1.使w的2范数尽量小,2.使误分类的点的个数尽量少,C是二者的调和系数\n",
    "\n",
    "#综合以上,把学习目标写为如下:\n",
    "#优化目标函数:\n",
    "#最小化 -> w平方后求和再开方(2范数)/2 + C*(xi求和)\n",
    "#约束条件:\n",
    "#y * (w * x + b) >= 1 - xi\n",
    "#xi >= 0\n",
    "#分离超平面:\n",
    "#w * x + b = 0\n",
    "#分类决策函数:\n",
    "#sign(w * x + b)\n",
    "\n",
    "#书上并没有直接解上面的问题,而是转换为了对偶问题来解\n",
    "#优化目标函数:\n",
    "#最小化 -> 1/2 * sigma i=1 -> N sigma j=1 -> N alpha_i * alpha_j * y_i * y_j * (x_i · x_j) - (alpha求和)\n",
    "#写为伪代码:\n",
    "\"\"\"\n",
    "_sum = 0\n",
    "for i in range(N):\n",
    "    for j in range(N):\n",
    "        _sum += alpha[i] * alpha[j] * Y[i] * Y[j] * np.dot(X[i], X[j])\n",
    "_sum /= 2\n",
    "_sum -= alpha.sum()\"\"\"\n",
    "#约束条件:\n",
    "#求和(alpha * y) = 0\n",
    "#0 <= alpha <= C\n",
    "#解出这个方程以后,就可以算出w和b了\n",
    "#w = 求和(alpha * y * x)\n",
    "#b = y_j - 求和(y * alpha * (x_i · x_j))\n",
    "#这里的j是大于0小于C的alpha的下标,i是求和(sigma)的遍历符号,也就是说会求出多个b,可能并不相同,所以b不是唯一的\n",
    "\n",
    "#============核函数支持向量机============\n",
    "#优化目标函数,其实就是把上面的优化目标函数里的(x_i · x_j)替换为K(x_i,x_j):\n",
    "#最小化 -> 1/2 * sigma i=1 -> N sigma j=1 -> N alpha_i * alpha_j * y_i * y_j * K(x_i,x_j) - (alpha求和)\n",
    "#写为伪代码:\n",
    "\"\"\"\n",
    "#其实就是把上面的伪代码里的np.dot(X[i], X[j])改为K(X[i], X[j])\n",
    "_sum = 0\n",
    "for i in range(N):\n",
    "    for j in range(N):\n",
    "        _sum += alpha[i] * alpha[j] * Y[i] * Y[j] * K(X[i], X[j])\n",
    "_sum /= 2\n",
    "_sum -= alpha.sum()\"\"\"\n",
    "#书上没有提到约束条件, 是没有了还是和原来保持一致? 不清楚.\n",
    "#分类决策函数:\n",
    "#sigma i=1 -> N [alpha_i * y_i * K(x,x_i)] + b\n",
    "\n",
    "#解释下什么是K函数,phi函数是把x转换到另一个空间的函数\n",
    "#K(x_i,x_j) = phi(x_i) · phi(x_j)\n",
    "\n",
    "#============SMO支持向量机============\n",
    "#假设只优化alpha_0和alpha_1,其他的alpha固定\n",
    "#优化目标函数:\n",
    "#略,太长了\n",
    "#写为伪代码:\n",
    "\"\"\"\n",
    "_sum = 0\n",
    "#这里的Y[0] * Y[0]其实没有必要,因为一定是1\n",
    "_sum += Y[0] * Y[0] * K(X[0], X[0]) * alpha[0] * alpha[0] / 2\n",
    "#这里的Y[1] * Y[1]其实没有必要,因为一定是1\n",
    "_sum += Y[1] * Y[1] * K(X[1], X[1]) * alpha[1] * alpha[1] / 2\n",
    "_sum += Y[0] * Y[1] * K(X[0], X[1]) * alpha[0] * alpha[1] - alpha[0] - alpha[1]\n",
    "\n",
    "s1 = 0\n",
    "for i in range(2, N):\n",
    "    s1 += Y[i] * alpha[i] * K(X[i], X[0])\n",
    "\n",
    "s2 = 0\n",
    "for i in range(2, N):\n",
    "    s2 += Y[i] * alpha[i] * K(X[i], X[1])\n",
    "\n",
    "_sum += Y[0] * alpha[0] * s1\n",
    "_sum += Y[1] * alpha[1] * s1\n",
    "_sum\"\"\"\n",
    "#约束条件:\n",
    "#alpha_0 * y_0 + alpha_1 * y_1 = 0 - sigma i=2->N y_i * alpha_i\n",
    "#0 <= alpha <= C\n",
    "#虽然有alpha_0和alpha_1两个变量,但自由度只有1,一个变量确定时,另一个也就确定了.所以只需要计算出一个的值.\n",
    "#这里假设我们只考虑优化alpha_1\n",
    "#alpha_1的取值范围是 L <= alpha_1 <= H\n",
    "#如果y_0 != y_1,则L = max(0,alpha_1 - alpha_0),H = min(C,C + alpha_1 - alpha_0)\n",
    "#如果y_0 == y_1,则L = max(0,alpha_1 + alpha_0 - C),H = min(C,alpha_1 + alpha_0)\n",
    "\n",
    "#为了叙述简单,定义函数g\n",
    "#g(x) = sigma i=0 -> N[alpha_i * y_i * K(x_i,x)] + b\n",
    "#E就是g函数的预测和真实y之间的差\n",
    "#E_i = g(x_i) - y_i, i=0,1\n",
    "#训练算法:\n",
    "#alpha_1 = alpha_1 + {y_1 * (E_0 - E_1) / [K(x_0,x_0) + K(x_1,x_1) - 2 * K(x_0,x_1)]}\n",
    "#alpha_1 = H if alpha_1 > H\n",
    "#alpha_1 = L if alpha_1 < H\n",
    "#再计算alpha_0:\n",
    "#alpha_0 = alpha_0 + y_0 * y_1 * (alpha_1_old - alpha_1_new)\n",
    "\n",
    "#变量的选择:\n",
    "#首先要找到一个违反kkt条件最严重的alpha,记为alpha_0\n",
    "#kkt条件:\n",
    "#if alpha = 0 then y * g(x) >= 1\n",
    "#if alpha = C then y * g(x) <= 1\n",
    "#if 0 < alpha < C then y * g(x) == 1\n",
    "#第二个变量要找一个能使|E_0 - E_1|最大的alpha,记为alpha_1\n",
    "\n",
    "#每次优化完两个alpha后,要重新计算b,因为更新了两个alpha,所以会得出两个b\n",
    "#b1 = 0 - E_0 - y_0 * K(0,0) * (alpha_new_0 - alpha[0]) - y_1 * K(1,0) * (alpha_new_1 - alpha[1]) + b\n",
    "#b1 = 0 - E_1 - y_0 * K(0,1) * (alpha_new_0 - alpha[0]) - y_1 * K(1,1) * (alpha_new_1 - alpha[1]) + b\n",
    "#如果alpha_new_0,alpha_new_1同时满足 0 < alpha < C 那么b1==b2\n",
    "#如果alpha_new_0,alpha_new_1是0或者C,那么b1到b2都符号kkt条件,选择他们的中点作为新的b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[0., 0., 0., ..., 0., 0., 0.],\n",
       "        [0., 0., 0., ..., 0., 0., 0.],\n",
       "        [0., 0., 0., ..., 0., 0., 0.],\n",
       "        [0., 0., 0., ..., 0., 0., 0.],\n",
       "        [0., 0., 0., ..., 0., 0., 0.]]),\n",
       " array([-1,  1, -1, -1, -1]))"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import random\n",
    "\n",
    "\n",
    "#加载数据\n",
    "def load_data(file_name):\n",
    "    N = 100\n",
    "    \n",
    "    #可分不可分都可以处理\n",
    "    with open(file_name) as fr:\n",
    "        lines = fr.readlines()\n",
    "\n",
    "    x = np.ones((N, 28 * 28), dtype=float)\n",
    "    y = np.empty(N, dtype=int)\n",
    "\n",
    "    #就加载100个数据,太多了算不动\n",
    "    for i in range(N):\n",
    "        line = lines[i].strip().split(',')\n",
    "        x[i] = line[1:]\n",
    "        y[i] = line[0]\n",
    "\n",
    "    #压缩到0-1之间\n",
    "    x /= 255\n",
    "\n",
    "    #如果是0,y就是1,否则就是-1\n",
    "    y[y != 0] = -1\n",
    "    y[y == 0] = 1\n",
    "\n",
    "    return x, y\n",
    "\n",
    "\n",
    "X, Y = load_data('./mnist_train.csv')\n",
    "X[:5], Y[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#定义常量\n",
    "N, M = X.shape\n",
    "\n",
    "C = 200  #惩罚参数,C值越大时,对误分类的惩罚越大\n",
    "\n",
    "alpha = np.zeros(N)  #拉格朗日乘子\n",
    "b = 0.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9542724028981369"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#这个函数就是高斯核函数\n",
    "def K(i, j):\n",
    "    #l2 = ((X[i] - X[j])**2).sum()**0.5\n",
    "    l2 = np.linalg.norm(X[i] - X[j], ord=2)\n",
    "\n",
    "    return np.exp(-l2 / 200)\n",
    "\n",
    "\n",
    "K(0, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#g(x) = sigma i=0 -> N[alpha_i * y_i * K(x_i,x)] + b\n",
    "#预测函数\n",
    "def g(i):\n",
    "    _sum = 0\n",
    "    for j in range(N):\n",
    "        _sum += alpha[j] * Y[j] * K(i, j)\n",
    "    _sum += b\n",
    "    return _sum\n",
    "\n",
    "\n",
    "g(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#E = g(x) - y\n",
    "#误差函数\n",
    "def E(i):\n",
    "    return g(i) - Y[i]\n",
    "\n",
    "\n",
    "E(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(False, 1.0)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#kkt条件:\n",
    "#if alpha = 0 then y * g(x) >= 1\n",
    "#if alpha = C then y * g(x) <= 1\n",
    "#if 0 < alpha < C then y * g(x) == 1\n",
    "def kkt(i):\n",
    "    if alpha[i] == 0:\n",
    "        return Y[i] * g(i) >= 1\n",
    "    if alpha[i] == C:\n",
    "        return Y[i] * g(i) <= 1\n",
    "    if 0 < alpha[i] < C:\n",
    "        return Y[i] * g(i) == 1\n",
    "    return False\n",
    "\n",
    "\n",
    "def get_kkt_difference(i):\n",
    "    if kkt(i):\n",
    "        return 0\n",
    "\n",
    "    if alpha[i] == 0:\n",
    "        return 1 - Y[i] * g(i)\n",
    "    if alpha[i] == C:\n",
    "        return Y[i] * g(i) - 1\n",
    "    if 0 < alpha[i] < C:\n",
    "        return np.abs(1 - Y[i] * g(i))\n",
    "    return 100\n",
    "\n",
    "\n",
    "kkt(0), get_kkt_difference(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 1)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def pick_idx():\n",
    "    #首先要找到一个违反kkt条件最严重的\n",
    "    max_kkt_difference = 0\n",
    "    _i = -1\n",
    "    for i in range(N):\n",
    "        if kkt(i):\n",
    "            continue\n",
    "\n",
    "        kkt_difference = get_kkt_difference(i)\n",
    "        if max_kkt_difference >= kkt_difference:\n",
    "            continue\n",
    "\n",
    "        max_kkt_difference = kkt_difference\n",
    "        _i = i\n",
    "\n",
    "    #第二个变量要找一个能使|E_0 - E_1|最大的\n",
    "    max_E_difference = 0\n",
    "    _j = -1\n",
    "    for i in range(N):\n",
    "        E_difference = np.abs(E(_i) - E(i))\n",
    "        if max_E_difference >= E_difference:\n",
    "            continue\n",
    "\n",
    "        max_E_difference = E_difference\n",
    "        _j = i\n",
    "\n",
    "    return _i, _j\n",
    "\n",
    "\n",
    "pick_idx()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 200)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#如果y_0 != y_1,则L = max(0,alpha_1 - alpha_0),H = min(C,C + alpha_1 - alpha_0)\n",
    "#如果y_0 == y_1,则L = max(0,alpha_1 + alpha_0 - C),H = min(C,alpha_1 + alpha_0)\n",
    "def get_L_and_H(i, j):\n",
    "    L, H = 0, 0\n",
    "\n",
    "    if Y[i] != Y[j]:\n",
    "        L = max(0, alpha[j] - alpha[i])\n",
    "        H = min(C, C + alpha[j] - alpha[i])\n",
    "    else:\n",
    "        L = max(0, alpha[j] + alpha[i] - C)\n",
    "        H = min(C, alpha[j] + alpha[i])\n",
    "\n",
    "    return L, H\n",
    "\n",
    "\n",
    "get_L_and_H(0, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.9542724028981369"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def get_b(i, j, alpha_new_i, alpha_new_j):\n",
    "    #b1 = 0 - E_0 - y_0 * K(0,0) * (alpha_new_0 - alpha[0]) - y_1 * K(1,0) * (alpha_new_1 - alpha[1]) + b\n",
    "    #b1 = 0 - E_1 - y_0 * K(0,1) * (alpha_new_0 - alpha[0]) - y_1 * K(1,1) * (alpha_new_1 - alpha[1]) + b\n",
    "    b1 = 0 - E(i) - Y[i] * K(i, i) * (alpha_new_i - alpha[i]) - Y[j] * K(\n",
    "        j, i) * (alpha_new_j - alpha[j]) + b\n",
    "    b2 = 0 - E(j) - Y[i] * K(i, j) * (alpha_new_i - alpha[i]) - Y[j] * K(\n",
    "        j, j) * (alpha_new_j - alpha[j]) + b\n",
    "\n",
    "    #如果alpha_new_0,alpha_new_1同时满足 0 < alpha < C 那么b1==b2\n",
    "    if 0 < alpha_new_i < C and 0 < alpha_new_j < C:\n",
    "        #print('b1==b2 = ', b1 == b2)\n",
    "        return b1\n",
    "\n",
    "    #如果alpha_new_0,alpha_new_1是0或者C,那么b1到b2都符号kkt条件,选择他们的中点作为新的b\n",
    "    return (b1 + b2) / 2\n",
    "\n",
    "\n",
    "get_b(0, 1, 1, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(21.868632147287173, 21.868632147287173)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#训练算法\n",
    "def get_new_alpha(i, j, L, H):\n",
    "    #再计算alpha_1:\n",
    "    #alpha_1 = alpha_1 + {y_1 * (E_0 - E_1) / [K(x_0,x_0) + K(x_1,x_1) - 2 * K(x_0,x_1)]}\n",
    "    alpha_new_j = alpha[j] + Y[j] * (E(i) - E(j)) / (K(i, i) + K(j, j) -\n",
    "                                                     2 * K(i, j))\n",
    "\n",
    "    #alpha_1 = H if alpha_1 > H\n",
    "    #alpha_1 = L if alpha_1 < H\n",
    "    if alpha_new_j > H:\n",
    "        alpha_new_j = H\n",
    "    if alpha_new_j < L:\n",
    "        alpha_new_j = L\n",
    "\n",
    "    #再计算alpha_0:\n",
    "    #alpha_0 = alpha_0 + y_0 * y_1 * (alpha_1_old - alpha_1_new)\n",
    "    alpha_new_i = alpha[i] + Y[i] * Y[j] * (alpha[j] - alpha_new_j)\n",
    "\n",
    "    return alpha_new_i, alpha_new_j\n",
    "\n",
    "\n",
    "get_new_alpha(0, 1, 1, 100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def train():\n",
    "    global alpha\n",
    "    global b\n",
    "\n",
    "    iterStep = 0  #迭代次数\n",
    "\n",
    "    #判断收敛或者迭代次数达到上限\n",
    "    while (iterStep < 5):\n",
    "        iterStep += 1\n",
    "\n",
    "        #找到本次要优化的两个alpha\n",
    "        i, j = pick_idx()\n",
    "\n",
    "        L, H = get_L_and_H(i, j)\n",
    "\n",
    "        #训练新的2个alpha\n",
    "        alpha_new_i, alpha_new_j = get_new_alpha(i, j, L, H)\n",
    "\n",
    "        #训练新的b\n",
    "        b = get_b(i, j, alpha_new_i, alpha_new_j)\n",
    "\n",
    "        #更新参数\n",
    "        alpha[i] = alpha_new_i\n",
    "        alpha[j] = alpha_new_j\n",
    "\n",
    "\n",
    "train()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "accuracy= 0.98\n"
     ]
    }
   ],
   "source": [
    "#测试\n",
    "def K_for_test(x1, x2):\n",
    "    difference = x1 - x2\n",
    "    l2 = np.linalg.norm(difference, ord=2)\n",
    "    return np.exp(-l2 / 200)\n",
    "\n",
    "def predict_for_test(x1):\n",
    "    _sum = 0\n",
    "    for i in range(N):\n",
    "        _sum += alpha[i] * Y[i] * K_for_test(x1, X[i])\n",
    "    _sum += b\n",
    "    return _sum\n",
    "\n",
    "\n",
    "test_X, test_Y = load_data('./mnist_test.csv')\n",
    "\n",
    "\n",
    "correct = 0\n",
    "for i in range(N):\n",
    "    pred = predict_for_test(test_X[i])\n",
    "    pred = 1 if pred > 0 else -1\n",
    "    if pred == test_Y[i]:\n",
    "        correct += 1\n",
    "\n",
    "print('accuracy=', correct / N)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x864 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     -         -         -         0         -         -         -         -         -         -    \n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x864 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     -         -         -         -         -         0         -         -         -         -    \n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAq8AAABKCAYAAACVd72FAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOydZ3Ob15n3/yAJAgRAVBIdIACSYC8Sm6olWZbkTeSStTeZxJstyb7IzuzuB9gvsB9g90Uys9ln4vRkpTiObblINq1GSmLvBSAIohKFANEbcT8vtOeYpHoHKPxmNNKIAHjfB+c+5zpX+V8shmFQokSJEiVKlChRokQxUPaiL6BEiRIlSpQoUaJEiYelZLyWKFGiRIkSJUqUKBpKxmuJEiVKlChRokSJoqFkvJYoUaJEiRIlSpQoGkrGa4kSJUqUKFGiRImioWS8lihRokSJEiVKlCgaKh7lxTU1NYzBYHhGl/LiWV1dRSAQYD3s6/f6eADA6OhogGGY2od5bWk8dlIaj52UxmMnpfHYSWk8dlIaj52UxuNO9vqY3M8meyTj1WAwYGRk5OlcVQHS29v7SK/f6+MBACwWy/6wry2Nx05K47GT0njspDQeOymNx05K47GT0njcyV4fk/vZZKW0gRIlSpQoUaJEiRJFQ8l4LVGiRIkSJUqUKFE0PFLaQIkSJUqUKFGi+GEYBvl8HltbW9ja2kI+n8f2dvEVFRVgs9koKysDi/XQpSAlSjwXSsZriRIlSpQo8ZKRTCYRj8cxMzOD4eFhrK6uwmazobKyEhUVFTh79izeeust8Hg88Pn8F325JUrsoGS8FgG5XA75fJ7+YbFYYLFYKC8vR0XF7a+wdDIuUaLEdhiGod414lXL5/P0Z7sh6wr5d1lZGcrLy3f8f6FB7oNhGGxtbe24r7KyMuo1LNTrf5Gk02lsbm5ifn4ek5OTmJqawuLiIioqKsDhcFBfX4/jx4+joqKiZLyWKDhKxmsBQzYdi8WCsbExTE1NYX5+HjKZDHK5HKdOncLAwADYbDY4HM6LvtwSJUoUEIlEAolEAh6PBy6XC4uLi7DZbAiHwwiHw9SQBW4bemKxGEqlEtXV1ZDL5WhqakJnZyc4HA6qqqoKzgAkoe50Oo1sNouFhQWsra0BuH0/HR0dkMvl4PF44HK5L/hqC4+FhQV89NFHGB8fx+joKBKJBACgsrISPB4Pq6ur+NOf/oQTJ06gp6en4L7/Ei83JeO1gCH5SD6fDxMTExgeHsa1a9egUqlgMpmg0+nQ3d2NsrK9VXdHvCfE40w8J8STAjy5p5n8DvL5e20MS+x9tntUgW88rYRoNIpwOAybzYb5+XnMz89jfHwcPp8Pfr8fZWVlYLPZKC8vB5vNhlKpRGtrK0QiEdLpNEQiEVpaWsBms1/ULd4ThmGQy+WQy+UQjUaRSCQwPz+P5eVlAEB5eTkkEgnKy8vpukH+/bIbYcQDv76+juXlZVgsFgSDQbDZbPB4PAiFQojFYgCA3+9HMpl8wVf8bMnlctja2toxP172OUIgzxh5hrbvwS+akvFawORyOaTTaYyMjODcuXMIh8NgsVgIhUKYmZlBS0sLurq6UFdXBx6P96Iv96lBHpjh4WEMDw9Dq9VCLpejsbERCoUCbDYblZWVj/355FCQTqcRDAbB5XIhk8loiLREiUKHYRi4XC4EAgGEQiFEo1HYbDYEg0H6mrW1NbjdboTDYcRiMUQiEUSjUWSzWQCA2WxGX18ftFotzGYz6urqYDAYUFFRgYqKCnC5XFRVVRWcwbe1tYVcLoeFhQU4HA5cuHABVqsVbrcbsVgMwO3D7aVLlyCRSLB//340NDTgyJEj0Ol0qKioQHl5+Qu+ixdHNBrF5uYmpqamMD09jY2NDQBAd3c3ent70dzcjK6uLmqo6HS6gvr+nyYMw+DGjRu4dOkSTpw4gcbGRgiFwj21nz4uDMPg2rVrOH/+PDo7O9Ha2gqTyQSFQvGiLw1AyXgtWBiGQTabRTwex/r6Og2HsVgspNNppFIphMNhBAKBgplMTwOGYZDJZJBKpTA5OYnr16/DbDZDo9FALpdDJpPRPN/HhRiusVgMXq8XIpEIEomE5hGXKFHoMAyDYDAIi8UCh8OBzc1NLC8vw+l00jlss9ng8/nuiCxwuVzw+XyYTCY0NjaiqakJ7e3tkMlkqK196OY+LwTicc1ms3A4HJiZmcHly5cxNzd3x2vtdjvKysqQTqcRDodhMpkgl8vBMAz1ru1Vo+xeMAyDeDyOQCBADz65XA5sNhs6nQ7Nzc3o6emB2WxGJpNBJpOBQCB40Zf9TCCRiuXlZVy9ehVarRZqtbqU34tvxmZ+fh4XLlxAPp9HZWXlQ9ka21UsANDD79PeW0vGawFCPI9jY2P44osvMDw8/KIv6blA7vv8+fP46quvMD09DZfLBQ6HQx8APp//2GEL8kCtra3hZz/7GcLhMNbX19HV1YV/+7d/A4/HK8jcvhIldpPP5/Hpp5/i3LlzSKVS9MCXzWahUCggkUhw4MABVFdXQywWQyQSgcvlgsvlor6+HlqtFnw+H3w+HxwOBxwOpygObltbW5ifn4fdbsfvfvc7TE5Owul03vW1ZBOdnJyE1WqF3W6HVqvF66+/jv3790MikexZw+xukPX14sWL+PDDDzE1NYVIJEI97mfPnsXrr7+OqqoqcLlcOn7FMC8eh0QigWQyCavVioWFBaRSKVRVVe3Z+30UkskkEokE7HY73G431tfX4fF4kEql7vu+ra0tZLNZLC8v4+c//zkUCgV6e3uh0+lgNpufasrBMzVet1e77uZuJ9+X3Wgg+WvZbBbZbBaLi4u4efMm7Pa7d4zL5/M0X2dra+uOauFignhU0uk0xsfH8fHHHyOdTiOXyyGVStFF9Em8rvl8HtlsFj6fDxcvXkQ4HEYymYRQKEQmkynqorftuY7kududA7ndA1es8+R+bM9jvtv9E7avPdvHg7y+WDxyTqcTExMT9Lo5HA4qKyvBYrFQXV0NtVoNrVYLpVIJuVxO0wD0en3Be1jvBcMw8Pv9WFxcpNXxBJL2s9v4iEQiCIVCiEQiEAgEkMvl0Gq1OwrRCiWP71lC0i0sFgsGBweRSCSQyWQgFouh1+vR0NCAmpqaopn/TwKJ8JG5QQoYKyoq7nnv222Zve65J2ND8sljsRhSqRRyudx930fGyOVy4c9//jOamppoTn1jY+NTvcZnZrzm83kEAgFsbm5idnYWHo8HQqEQHA6HFgk0NDRAKpXSUz/52csIwzDwer3wer1YWlqCw+HA9evXMTU1hXg8ftf3eDweTE1N0ROkQCBAdXU1+Hw+qqurn/MdPD7ZbBa5XA5DQ0MYGRnBjRs3EI1G0dfXB6PRiHfeeQddXV2QyWRP9Hui0ShGRkYwNDSEtbU16PV6/PCHP0RXVxckEgnYbHZRLkak2pp4VgKBANxuN7xeL5xOJ70nk8mEtrY28Pl8iMVisNnsPVWFnUqlkEqlsLS0hKmpKTgcDrhcrjsMeI1Gg8bGRjQ3N6O5uZmKsafTaWxsbIDH40EkEhVUccLdMJvNOHnyJKampuDz+VBTU4Oamhr85Cc/wYkTJ6gxy2az6aZMirSKFRaLBaFQCIVCgaqqKvr/5eXlOHLkCPR6PWpqasDn82lB25UrVzA1NYVsNotgMIg//elPmJycxMGDB3H48GEYDAYolcqC/76fBJIusLGxAZ/Ph1gsRsO6PT09ePfdd2EwGPa0QbYdhmEwMzODr776CouLi6isrIRAILiv59Xn82F+fh7V1dWQSCT0z16DYRhYrVZcuXKFHg5FIhGUSuWOZ+5e72UYBul0GqFQCGtra7BardBqtU/9Op+Z8cowDMLhMNxuN65du4a1tTWIxWLweDyw2Wy6oAIAj8cDh8N5aifgYvVAbmxsYH5+HqOjo1hZWcHU1NSOAozdRCIReL1eerJRKBRQKpUAAD6fXzQLEfEITExM4Pr167Db7chms1Cr1WhubkZbWxv0ev0T/Q6GYRCLxTA+Pg6bzYZEIgGBQICenh4YjUZUVlYWVbhou2eR5Ean02mk02msrq5iYmICa2trWFhYoM9VR0cHqqqqIJfLUVFRAR6Pt8PTUKweKGKcZjIZbG5uYnp6GoODg5iamsLc3NwOD2xZWRmam5tx6NAhbG1tQa/Xg8vlgsViIZFIwOv1QiqV0nByoY4Hi8WCQqGAyWSCzWaD3+9HVVUVJBIJOjs70dDQUBTP/uNADl3keSUGucFgQHNzM/R6PSQSCY20OJ1OWK1WRCIRpFIpLCwsYHl5GWw2G1VVVeDz+aipqUFFRUXBft9Pg2QyiVAohFgshkwmQxUYFAoFjEYjqqur9+yc2Q451KyurmJmZgahUAh8Pp8arvcag2g0ivHxcSiVStTV1aGiogJisXhPjRlZK4mh7vV6AdyWT6uurn6oyCfxaieTScRiMWxubiIWi901CvYkPFPP66VLlzA8PIypqSn4/X7auYNMkOHhYUgkEmq8qlQq1NTUPPbvrKyshEgkgk6nQ0tLCzgcDjXiCh2GYXDlyhX89re/hd/vRzQaRSQSue97nE4nvvzySwgEAkgkEshkMigUCgwMDODs2bPgcDjg8XgFff/EIxAKhTA/P4+bN29ic3MTLBYLvb29ePPNNyGXy5/od2SzWZrbdO7cOQDAkSNH0NPTg3379kEoFBbVppVKpZBOp+FwOLC2toa5uTmsrKwgHo8jkUhgY2MDwWBwxxwqKyvD2toaJicnUV1dDaFQCJFIBLVaDZFIBIPBAK1Wi9bW1qJRXSALbSwWQywWw+DgIK5evYrl5WUsLS3Re999L263G19++SXVtSSpKV6vFzMzM2hra8MPfvADSKVSKBSKgpwbZWVlOHr0KJqampBOpxGNRpFOp+F0OhEIBJBMJul6u5fI5/NYWFjA6Ogolfvq6uqCwWDAD37wA7S2tlLnCJkftbW1OHHiBD755BN88cUXNFIxNDSE1dVVWK1WHDp0CPv27aNGfzHM/0clGAxidnYWgUAAAGA0GmEymdDT00MPtHsdhmGwsbGBUCgEi8UCv9+Pd999F/39/WhubkZlZeU9n3cWi4WKigq43W6srq7i+PHj0Ol0z/kOni3JZBKpVArT09MYHR2Fz+cDAJqG9KBIXSqVgsPhgN1uf+rG6m6eqefVZrPh1q1b8Hg8iMVidEEgN7W0tAQANLyl1WqhUql2TJ675csSdr9OKBRCIpGgtbUVarUaQqGwKCoHSXeYlZUVXL169aE3S5KTQj5DKBSitrYWXC4Xhw8fpgeDQoZhGCQSCWxubsLv92N9fR1lZWXgcDgwGo3QaDRPJItFcmljsRjW1tYwNTUFhUKBjo4OGI1GyGSyokgX2K7lmU6nEYlEsLi4iFu3bmFychLj4+OIx+OIx+N3RB5IDqjf74fFYqE/F4vFqKurg1ar3VFlXCyqCyS/Kh6Pw+/3Y3R0FB9//DF9LsrKyujcyefz9LlKpVJwOp1YXFyEUqlEIpGA3++H3W6n43jixAlUVFQUrJIHi8WCTCaDUCiERqOBSCRCIpFANBqlclhPmiNeiDAMA7fbDafTiWQyibKyMtTV1cFoNKKxsRFqtfqO9zQ1NaG2thbz8/Pg8/nUM+TxeODxeFBWVkaNXKPRSD2SewmGYRCNRuHxeOieIZfLYTQaIZfLHxgO3ktEIhF4PB6EQiEkk0l0dXWhv7//gYc9si7GYjG4XC60t7c/x6t+9pC9JRwO05SzeDyOsrIyqlDyoPUkm80iEAggHA4D2Jkb/LT32Ge2spWVleHNN99EQ0MD1tbWEI1GIZVKwePxEAwGkUgkEAgEEIlEYLfbqbcoEAiAz+dDIBDQZOHdkIEgnlXSo7m8vBxcLheRSAQqlQpNTU1UqLpQYRgGk5OTmJycxNjYGN2Q7/dFk+pgkquXTCYRiUSQTCaxvr6OTz/9FOvr6zh9+jTee++9gr1/kqdps9kwMzMDr9eLsrIyfOc730FzczPa29vvexJ+mM8nOZC//vWvsby8jGw2i9raWvT29qKtrY3mXxcyyWQSmUwGa2tr8Hq9GBsbw+rqKux2OxwOB32OKisrIZPJoFQqodVqaf7zwsICbt26BaFQCKVSic3NTayvr9OFamtrixZvNDY2QiaTQaPRFKTHcTvJZBLJZBJ/+ctf8OWXX2J2dhYbGxtgs9mQyWQ4duwY9u/fj7Kysh2LLilAkEql0Gg0mJmZwbVr1xAOh1FeXg4ej4fq6uqCzwcmKR+9vb2Ix+P4+uuvsbi4iM3NTaRSqSc69BUqRNpoaGgIm5ubqKiowIEDB3D06NF75h8SRYXvfve7MJvNuHHjBm7dugWv1wufz0dTCnK5HCKRCNra2lBfX79nPLDZbBZbW1tYXl7GxMQE3G43WCwW2tra8Prrr9NUs5eFaDQKp9NJ18i6urqHUtvgcrnQarXY2Nigxu9egRR9Dw8P44svvsCVK1cQiUTQ0NAAo9GIV155BWaz+YFFzclkEhaLBT6fjzoUGxoanomH+pkaryaTCVKpFC6XC+FwGDqdDjweDz6fD4FAgOZqbW1t0XycSCRCK8sjkQi14LdD3PfktEg8L4Sqqip0dHRAIpE8c9f1k5LP5zE1NYXPPvsMVqv1ga9nsVi0fR+Hw6EbbCwWQzabRSaTwcLCAhYWFiAWi/H973+/4ETGgW+8zZlMBk6nEzabDZFIBGVlZWhqasKrr75K89Ael62tLcTjcSwtLeH8+fPU4yAWi2llLemqUohsT36PRqOYmZnBxMQEhoaGMD09TSWSCKTQyGAwoL6+HiKRCDU1NchmsxgdHYVAIEBdXR2cTifW19eRz+eRyWQQCoWwubmJ6upqLC4uoqGh4a4erEJiu5fg1q1b+N///V8At58PLpeL6upqNDc349SpU/SQRyB5WMSotVqt8Pv9SKfTtNUyl8st+MImkt5BcsPHx8dp0Vomk7lv1KpYIfq2RB6Lz+fDbDbDZDLdc2Mlh/36+npIJBKkUinqQPH5fAiFQgiFQjTnUSAQwGQyASiumol7QeSL1tfXYbVaaXRGqVSisbGxqIp7nxSGYZBMJrGxsQGJRAKFQgGhUPhQzzrJcS0vL4ff70c8HqfqJMUOkZGcmJjAxx9/DJ/Ph1QqBYVCQRuYCIXCB35OJpOB3++nzUJ4PB4d46LxvLJYLEgkEtonO5fLgcvloqysDGq1GrlcDgcOHKCbZyQSgcvlgt/vh0ajgVKphMvlgsfjueOzSYESqTq9fPkyfvrTn1LxfjJgIpGoYCcWydWLx+Ow2WxYW1tDMpm8r4vdbDajvb0dKpUKOp2ObrIejwerq6uwWCwYGhqiBrvP58Pi4iJqamqgUCgKaizy+TxmZ2extLSEjz76iBbWNDQ0oKenB83NzU+c8kDCw6urqwiHwxCLxRgYGMChQ4fQ2dlZ0PnA+XyeCtCPjY3B5XLBarXC4XDA6/UikUhAqVSitrYWtbW1EIvF2L9/P/r7+yEQCCAQCGjuH/G+9vX14dvf/jbGxsbwxz/+kXZdIq+xWq34xS9+gQMHDqCpqYl69wttjIhxdunSJVy+fBk3btwAALpuHD58GN3d3TQXcvfzlE6nEY/HYbFY8NFHH8FisSAajUKtVuPAgQMYGBiAwWCgslPFwPYCvnA4TAs97yZtU1lZSe+tUA9u94LFYsFgMKCzsxOrq6vY2traoaZwP0ix8IkTJ6BSqfDRRx/B4/HQQ//a2hrS6TSkUikaGhogFotpm9RihaQLud1uLCwsYHV1le7FPB6P7skvAyTX+ebNm/jyyy+xf/9+NDY2PvL9JxIJuN1u+P1+pFIpVFRUFHWUgxRoEaUjn8+HRCIBFosFo9GIgwcPQiqVPtRnRaNRzM3NwWazAbh9uFQqlc9ET/mZGq/EM/qgkx0Ja4TDYYTDYdTW1kIgECASidy12p54TEh4DwDef/99qnXK4XAgFosLPuwXj8dpqoTf70cmk7mn8UoW7fb2djQ1NcFsNtNNyOv1YnZ2FgB2NDQIBoOYn5+H2WxGbW1tQYXH8/k85ubmcOPGDQwNDcFut6OpqQk6nQ5arZa2a31ciGfO4/HQk6BKpUJrays6Ojqe+POfNQzDYGlpCVeuXMHQ0BAtQCIi0SwWC1KpFI2NjVCpVFAoFDh9+jTa2trukPxpb2+HwWBAa2sr+vr6wOFwMDo6CofDsSNi4ff7MTMzg6qqKmQyGdomtJAg+YqxWAxDQ0P43//9X5pPX1tbi4aGBhw8eBAHDx6EWCy+66JJPHEMw1BVhlQqBZFIhI6ODnR0dEAgEBT0/NjOdv1JcigmIfW7eV9FIhHKy8uL5v62w2KxIJfLUV9fTw9x5F62r5m7I24kYsVms6HRaMDj8TAzMwMej4d4PE6dKKFQCFarFS6XC2VlZQXtAHlYgsEgFhYW4HQ6EQqFaLMKUmvyMhivpPYhlUphZWUFN2/eRENDwyPXO2yvOYhEInTPLmbIAWd2dhYul2tHkW9tbS1MJtNDG5/JZBJra2vw+XxUe1osFj+TnOqC2JnIwiMSicDn8+lJ+n55Z6RN6vr6Omw2G6LRKCoqKmjxSXd3NyQSSUE+mER8/6uvvsKNGzdw8+ZNBAKBO7pXEN05k8kEvV6P48eP4+jRo1TPlRgpAoEAYrEY0WgUIpGIhg4tFgv++Mc/0gry7dXThfbAlZWVQSgUQiqVUq/Qo14j2cQ3Nzdht9sxPT2NL774AhaLBcBtI+7v//7vUVtbW5Dzgki4kAjEZ599hqGhIbhcLkSjUZSXl1MDy2Aw4NChQ+ju7qbzpKam5q7fbS6Xw+bmJpLJJBiGgUKhwFtvvYWxsTEsLCwgkUhQubJCT7MBQGXklpaWEI1GoVQqqfF+6NAhqh99r1BgNptFOBzG6uoqFhcXaYirpqYG+/btg1KpLLjn424QXd/p6WlcuXKFNjMZHByEy+WinZJ2YzQa0dTUBLVaDZVKBaFQWDShY1KoplQqweVy76iJINXk4XAYLpcL6+vrNI+bQLoHyWQyvPrqq5ient7RXjaZTMLr9T6xrnQhwDAMIpEI3G43TZsi66xer7/vc7LXIPrXkUgEVVVVaGpqwv79+x967m9ubuLWrVtwuVw7WoyXlZUVbcEbWfdJN8/l5WUAwKuvvorW1lacOXMGRqPxsR2BxMHyLA6BBWG8EiNst5eHFGDdi1wuB7/fT933QqEQKpUKGo0GKpWqIMN+5ASYSCQwNDSEc+fO0WKr3YYD0W1sampCa2srDhw4gIaGhjuqYdlsNng8Hj0hMQxDpX8uXLiAYDAIo9GI5uZm1NbWFkwhAjG0yB8+n09De49zfcR4DQaDuHr1KiYnJ/H555/TsVUqlWhpaSk4byKB5AHb7XZMTk7i5s2bGBsboz8nh7u2tjZ0dnbi5MmTMBgMD6yO3l6Qlc/nIRKJ0N/fj83NTZoPl0qlCmJOPIh8Pg+r1YqhoSFYrVYkk0mal3Xo0CH09PTQcOi9IMb8+vo6vF4v9U4KhUIqHVYMY0G+u5WVFdy4cQMbGxsAgImJCUxMTADAHTl5DMOgq6sLPT096OjowMDAALRaLQQCQVHcM1HJkEgk9wzV+v1+rKys4Ouvv8bKygqOHTuG7u7uO15XXV0Ns9mMjY2NHcYrkZt7UCvMYoFE+Iihz+PxIJfLUVNTU/BqNE8LhmEQCASwuLiIZDIJLpcLw/81p3jYkH80GsXy8jJNZSQtmXk8XtHmvpJc18XFRXz99deIRCK0mO/MmTMwm80QiUSP/JkEoqH8LBR9CnMXfwCkMm51dRW//vWvsbCwgK2tLeh0Orz11ltU9qJQw2LEyCLSNrvz0kgu45kzZ9Df3w+NRgOZTEYLjHZPgoqKCnC5XDQ2NuKv//qvsbS0hM8++4wW5CwvL+NPf/oTDhw4gObmZho2LaSHjYTJ/X4/fve736GzsxNVVVWorKykouP3goRJNzc34Xa7MTc3R0/IsViMCrcbjcaCuuftkHBvJBLBV199hbGxMTgcDgCgxtjbb7+Nzs5O9PT0QK1W33M+kM8jrYP5fD6OHDmCZDKJn//850ilUohEIrBardja2qKHJrFYjI6ODrS2ttLq20IZLyIq7nQ6cfHiRVy7do2GQAcGBnDq1CmYzWbaeOFukPv0+/349NNPMTs7SyXmSNcttVpd8G2Cicf15s2bmJiYoIarQCCg64RAIIBSqdyRs2mz2WjHnNXVVWxsbGB0dJQWrvT19aGvr48WrRViTiwpNNLr9bSLls/nw8bGBm3vOTg4iMuXL8Nms8Hn8yEajeLmzZt3fNbm5iaCwSB9zggrKyu4cuUKcrkcHUs+n1+UElpEsnJmZgbBYBAsFgvd3d3o7Ox8Yv3sYiGTyVBd36tXr0IgEODkyZNQqVRgs9kPnOMkJ9pms+HmzZuQSCT49re/jf7+figUiqKQWrwb+XweQ0NDNHWPRG7VajXa2trQ0tLy0OkCuVwO2WyWKjGQaBZJPXsWz01RGq+kc4rdbsf58+cRi8WQz+eh0Whw9OhRaDSagu+Wsr0LxW5qa2thNpvx+uuvY2Bg4I5q6d2QnC+5XI6jR48in8/j888/Rz6fRy6Xg8vlgtvtRmVlJZUUK7QNmmEYeDweeL1efPzxxzT3ksvl4rXXXruvpp7D4cDi4iLsdjsWFxdhs9mohjAA6q3U6XQFu8iQ8J7X68XU1BS+/PJL6vnhcrkQiUQ4dOgQTp48Sdtf3u+ziBc3lUqBy+Wis7MTY2Nj+P3vf0+l5XZXpAuFQnR0dKChoeGZLTiPC8MwmJ2dxeXLl3H58mUsLCzQgsWWlhb09PQ8lLwVaVs9PDwMi8WCfD4PgUAAs9kMvV6P6urqgrrvu0FUOi5evIi//OUvsNvtiEQiqK2thVarpTnjDQ0NMBgM9H3Xrl1DKpVCNBqF3W5HKBSiNQUsFgs/+tGPaPV5oX3/BJJeplarqdeQ1EqQQt6RkRGcO3eOHsxWV1cf6Xf4fD5cv34d1dXV6OrqoikKAApyTB6Ez+fDzMwMNjc3AQBarRb9/f2P7FErRsghPplMYnp6GhcvXsT3v/e52JAAACAASURBVP99dHV1PXTKBImU2u12zM7O4siRI9i/fz/a29uLJmJxN/L5PD777DP88pe/xMbGBpLJJNRqNerq6tDY2EgN84eBpFFsbGzsiFoQ26RkvP4f8XgcVqsV09PTiMViyOVyVCZIJpMVdBX5vSC5XNXV1Xj99ddx+PBh1NfXP9Imwufz0dzcDK/XC5PJhHA4TDtkFBplZWVoa2sDl8vF8vIyQqEQEokEcrkcnE4nwuEwFY2ORCK4evXqPT8rHA5TnWDiaQFuG32kBex3vvOdgva8AqDNBADs8HqShz8YDMLr9SIYDKK8vByJRGJHaJOkYcTjcepV8vv9iEQitM/0xsYG9SQQw5V47s1mM86cOQODwVBQXleCz+ejwtnA7evmcDj0ubnXQkvGlIwB6XVPChOMRiNOnTqF7u7ugrvn3WwvGCFpDyqVCi0tLXjrrbfQ29tLZfSqq6t35OJptVqcPHmSdiRbWVnB8vIy/H4/bDYbPB4P/vM//xMSiQQ6nY6qmxBPbCFAPK88Hg/vvPMO+vv7MTAwALVajbKyMiqzWFlZiXQ6ja2trUf+HaQv+40bN5BKpSAWi6FSqdDY2EhzJEkr1UJ2kBC2p6ORJg9jY2PI5XLQ6/VIJBI0z3d9fX3H64n0HJ/Ph8FggMFgoN35yM8LFRLh9Hq98Hg8NK2mqakJhw4deuhcV5K+SHLDeTxeUXzvd4M4NaxWK5xOJ+bm5hAOh2nh2fHjx3H48GEYjcaH8kpv/1zSyZKowWxvy/0sKErjNRwO48aNG1heXkY0GqW6p3w+vyjExe+FVCpFXV0djh07hkOHDoHD4TxSMj1psdvU1ASj0Qi73Q6/31+QRTgsFot6urRaLebn52nTApLHTK57Zmbmvovk7sWWQAyb+vp69Pb2FkVSPcmd2n4fJFwZDofhdDpp++DtCzIAKtni9/vhcDjg8XjgdrtRVVWF6upq2slsN2w2m34P+/fvh1AoLDjjlRTibJeUI0aVRCJ54Hebz+fh9/tx6dIljI6OYmVlBcDt+aLT6XDs2DFIpdKCuud7QZqSEKWSjo4ONDY24s0330Rzc/M936fRaADcDoNms1m4XC6MjY1hcXERHA4HNpsNFy5cgEQigcFgwJkzZ6DX6yEQCAqmfoAoAPD5fJw+fRrhcBgNDQ0QCARUKpEU/JK0mUclnU4jnU5jfHwc4+Pj1Bg+c+YMRCIRVCoV1YQtFiOGGBL5fB5ra2uoqqrC5uYmamtr4fF4EAgEMDExQVNpyJpKxrumpgbHjh3Du+++C5PJ9Ex0O58FDMPA6XRiYmICgUAALBYLzc3N1Dh7GMrKyugayefzqbxYMdz/bkiO67Vr1zA0NISJiQka4i8vL8e+fftw6tQpiMXiR6oNIdFw8gw+D43pojJeyaKyvLyMr776CsvLy2AYBs3NzTh79iz6+vogFouLJgdlu8RNeXk5zp49i9OnT6OlpYVqbD7u5+7+AwAulwvDw8Oor69He3v7Cw2BESm1iooK/PCHP8TBgwepTIfX60U4HKbdYIgRbzKZ7tqpQ6VSQa1WY3R0FJ988gn9f6FQiJaWFtocoxA1SwmkEKW8vBwmkwkulws2m422MMxms7h+/TpWV1eRSqWQTCaxublJ26ASg5c09yDd6fL5PNLpNIDbRsvu31dXV4empiYcPnwYra2tEIlEe6b6mOSGkgjE1atXMTg4SJuBVFZWgsvlQiqVFkUrZUJ1dTU4HA7+5V/+hRqYYrH4oTslkedeLpdjYGAALS0tOHr0KO3EFovF4Ha7YbPZ8P7776OzsxOHDx+m4/WinyFS3KvRaGjRETEwy8vL8dprr6Gqqgpra2twuVxU39Plcu047D0sZGOenp7Gr371KyiVSrS3t6Ourm6HZ/pFj8v92F4YS1rrEh32cDiMSCRCo3REJ5rUZJBw8Pj4OLa2ttDZ2YlvfetbkEgkqKmpKdj7JmlzN2/exNWrV5HP59HS0gKRSPRIewGZbwqFAu3t7UWtQkGKPK1WK0ZHR3c0gWIYBl9//TXC4TBaWlqgVCqh0Wh21JtsL67fbj8kEgmsrKzQ5iHPg6IyXkn3hrGxMXz00Ue00Km1tRXvvfceZDIZ+Hx+wT5Mu9ntMTxz5gxee+21p/bZu41Xt9uNixcvIhKJUPmsFwUxXquqqnDw4EH09/cjGAzSTlI2mw3BYBBut5sKand1daGjo+OOz+rr60NTUxN++ctf3mG86vV66HS6ghfjZrFYEAgE4HA4aGhogM/nQzgcRiwWo+kUg4ODO16//d8kZHo3LzvxtO2GNDYYGBjAd7/73YIs5HsSiK6j3W6nzQwuXLhAf15RUUFlg0iXnUK/dxaLBR6PBx6Ph+PHj+P48eOP/BlkAxKJRDvyHoke8NTUFEKhEBYWFjA4OIjXX38dzc3NBaOdTdJodhdxlpeXg2EY9PX1oa6uDkNDQ7BYLIjFYkilUtQIe1RI3qTVaoXVaqUd+g4fPgytVguhUFgwaRV3Y/daQdID7vVagUAAnU5HC2+I04ioWBw7dgxisRidnZ2QyWQF+8wQQ218fBx/+ctfcOTIETQ2NkIoFD6SY4g8L+R7f5hOU4UIcZZls1nYbDaqSLL95xcuXMDg4CAOHDgAg8GAb33rW2hra6Ov2d55cLv9EIvFMDk5CbfbDeCbOfcs50ZRGa+JRIL2d8/lcqiurkZNTQ2MRiNqamqKJizs9Xrv8AI8DcMqnU7D5XJhcXERKysrNERMTtxKpRInT55EfX19QRlyJEQtFotpH/KmpiY0NDTA6XSCy+WisrISRqPxrp0+SJENuSeS/9zb24s33ngDhv/rslTosFi32x4fO3YMTU1NOH78OILBIObm5uDxeODxeLC5uUk90URajBxQQqEQwuEwVV64F3K5HC0tLWhvb8fZs2eh1WoLTl1gN9sLdcjpPp1Og8Vi4cKFC9S7vB1SyGOxWLC8vEw1DAlisRjt7e1Qq9UFX+D5PCCFjaSaf3Z2FufOnYPX68Uf/vAHNDY24vDhw7Q5TCHOFTJPKisr8eqrr6Knp4fmvp48eXKH0UY8soTdub0ulwvz8/NwuVxYWVmhKjepVAoulwtLS0sYHByEyWRCR0cHKisri+LwR7xmUqkUIpEIJpMJCoViRxMHvV4Pl8tFBedJbjSJCH3++ecIhUJQqVTUU1to900O9UqlEkajEYlEAjabDaOjo2AYhhpiIpGIrn/3WwN4PB40Gg1CoRDm5uag0+nQ2dl5x+vKy8sLPspHrnG72gwAWgsxNzeHYDCIWCwGrVZL30dSM5VKJeRyOTKZDBKJBObn5zExMUELpUUiEbRaLdRq9TMbh6IyXqPRKKanp+H1erG1tQWhUIju7m40NjZCLBYXRR4KqX4dHh6G1+ulD8vT0F6Nx+NYWlrC0tIS7HY77ThGPl+n0+HgwYMQCoUFtVETTwo50RGPyt0WhrtBwujE8yIQCGD4vxaSRK2h0OcF8M0Jv6mpCU1NTTh48CC2trZw48YNjIyMYHFxEV6vl+Z1E48hye1zu91wuVywWCz3NV5JC9WBgQEcPXq0aNobkiYbxPtHjI/z58/j+vXrd7yepFVEIpEdB7ntn0dUBkrG6+3NWa/XQ61Wo7m5GXV1dfjqq69gt9vxX//1Xzh06BDkcjlUKhX4fH7BVt4TY6q2thbATvWN7TmwmUyGHoCAb9rmEmw2G86fP08N2EwmQ41Xj8eDfD4PHo+H1tZWqg9cKLnB94MUOtbV1cFgMKCvrw89PT00EiaXyyGRSBCJRODxeDA9PU3T9NxuN9bW1rC2toZoNIqenh5otdqCjHiSWgEi/USu/+uvv4bH44FKpYJUKkVLSwvVP7/fGlBVVYW6ujoEg0GMjo7CaDTeVR+bzWbTZ6PQxgTYabzujtYRL7vFYoHFYtlRKL3deDWbzaivr6fylJFIBBsbG0gkEmAYBhKJBPv27YNer39m91EUxitZfCKRCCwWC3w+H80NfOWVV9Dc3FwwwvsPgmEY2O12WCyWHfkmjwNJvibSOXa7HV9//TUWFxd3TMjy8nJagbwXN+hwOIylpSXYbDawWCzU19fjzJkz2L9/f8FK/jwMxBNaX18PsViMnp4e6nkl+YeVlZV0ARoaGkImk4HX693xOWQRr6urQ09PD5qbm3Hq1CkolcqiGR8Wi4XOzk6IRCJ6UFlfX6eG6W6tZOD2QpzJZNDa2oqWlhYEAgGsrq7C7/fD6/VCrVajt7cXGo2mKNaO5wXJaVMqlXjjjTewtraG69evIxKJ4JNPPoHJZEJ5eTmqq6shlUoLbk3Z2tqi+Y5bW1vUo3g358b28PHuRjlyuZymTKhUKjidTly5coUWPsZiMczPz4PFYmFoaAj19fXo6ekpqPEghbEHDx7ErVu34HA4oNVqUVdXh6NHj6Kvrw8qlQoymYxqcpJq+qqqKrpGSCQSDA4OYn5+HslkkqYTRCKRu0Y9CgFipJ04cQJ6vR4zMzMIBAJQKBQoLy+H0+mEzWaDw+GARCKhUb97sbS0hPn5eayurmJ9fR03b94En88Hn8+HRCKBRCJBbW0tJBIJ1Go1vYZCgUT2GIbB4cOHUV5eDpfLhUAggGAwiGQyeYcndreiTTabRTwex+rqKpLJJKLRKJ0LqVQKuVwOFRUV0Ov16O3tRX19/cvteSW5GhsbG5ienobD4UBFRQU1UmQyWVF4XYFvPK+7k6UfB5LTk0gkEAqFMDIyQnVvt09ANptNW4gWcmj4cXG73fjzn/+MmZkZALelUN5++23I5fKi8ITcC+KR1ul0dy1U2w2LxcLa2todOVnl5eWoqqpCT08P/u7v/g4mk4l2aiuWsSkrK0N9fT3q6urgdruRyWRw/fp1KpMWCoXu+d7u7m78+Mc/xvT0NIaHhzE7O0slpgYGBu7bAONlhEQAlEol3n33XZqDHggE8P7776O1tRWVlZVoampCb29vQRlrwDctLyORCBKJBA2J7z6kPSjvUSaTQSaTobm5Gfv27cPY2BiNbkQiEcTjcczNzSEQCAAAent70d3dXXAd/Jqammj9gNPpRHNzMzo6OvDuu++ipaXlnu8jnlixWAyDwQAOh4MvvvgCfr+f5hEHAoGHLhR83pB53NXVhfb2dnR1dcHr9cLpdGJjYwNLS0twOBwIBAKIxWJgs9k7PO+7a1Li8ThtJLOxsYEPP/wQH374IeRyOZqbm1FfX49Dhw6hvb0dCoWi4OYBABphIu1fh4eH4XA4YLPZ4Ha7d9RHMAyD9fX1HcZrJpNBJpNBNBrF2traHWNECif1ej1eeeUVyOXyl9t4jcVi8Pv9mJ6eht1uR1lZGYxGI3Q6HWQyWUFUwD4qT0NKIh6Pw263w+FwYHJyEvPz84jFYshkMgC+qaY2GAw4fvw49u3bh6qqqj1TTZ5MJpFMJrGwsIDp6Wk4nU56zySfqdjmxeMQjUYRDocxPj6O2dlZmjRPMJlMOHDgAHp7e9HU1ERTbIoNsjj29fXRntkOh4MWtRF4PB5trSwWi1FbWwu73Y7l5WXMzs4iEAhAJpNRb0sxH3CeJRUVFZDJZGhpacHf/M3fYHl5GX/+858RiURw+fJlRKNR7Nu3ryA2aYZhaAtki8UCt9sNj8eDaDSK1157DUajEVVVVY9VWMVmsyGVStHe3o4f/vCHmJ2dxW9/+1skEgnE43FaFKhQKBAKhagWaKHMKeJNJV63QCAAj8dz1wY5d4M8dwKBAPX19QBwxxpTyJDrJ3UxcrkcqVQKzc3NNK8zmUzSwzzRwSZeRYLH46HdPKPRKNra2nD8+HFIpVLodDrI5XLaDbKQnUREU57D4aCqqgqRSITKL+5OrbFYLHA6ndRoJxDN22AwSKXW1tfXaQMksVgMhUJx32Y6T8qLX3UeAp/Phy+//BIjIyNYXV2FyWTCvn370NraColEUrCT5Fmzvr6OTz75BGNjY/jwww/vEAXmcDioqalBX18f/umf/glSqbSoBZZ3E4lEYLPZMDQ0hIsXL9JqeWK8FkM4/Gng8Xhw48YNXL58GYODg3ccjLq7u/EP//APqKurQ11dXdE+L8ST0tLSgpaWFgwMDGBjY4N2kCNoNBpIpVLaaWp6ehrnz5/H+Pg4rl27BolEAo1GA4VCAYFAsGcOc08bkgNaXV0NnU6HhYUF6qn51a9+hc3NTfz4xz9+0ZdJ2djYgNfrxf/7f/8Pg4ODCAaDSCQSSCQSOHv2LEwm02MZr9vHwWg0YmpqClevXsX6+jo1YBcXFyEWi7G6ugqlUgmdTlcQ6w+LxQKHw6FavQDg9XpRUVGxwzC7H9vVKUwmEzKZDCYnJ5/lZT9VyH4nlUppwe/2fZKkmZD9k3gXA4HAjiY/w8PDCIfD1Kt/4sQJ/Pu//zvdb7ZLFhYypDhaLBZT7ed7sba2hpWVFdjtdrhcLvr/Go0GdXV1mJubw9TUFGZnZ6nxWlVVhZqaGtTW1j7TZ6CgjVfSqcFisWB4eBgrKytgs9loaGigcigvI6FQCA6HAxMTE7BarbR4YDeVlZW0KlAqlRZkUv2TEI/HqRYqcLvCsa6ujsrXFEMR0pMQj8eRSCQwMzODGzduYGVlZUcCPumMo1arodPpIBKJ9sT3T+6BzOfKykooFAr6cz6fT0OeLBYL4XCYhr4ZhgGfz4dOp4NUKi2anN8XCckFJeOWzWbhcDgKrvkJSaMiHeaSySQymQxNJ3rjjTeoIfo4BxaSOy6Xy/Htb38bFosF586dQy6XQyaTwfr6OkZHR9HW1gaNRlMw84qI7LNYLJqCt91gA+6fm0n61gcCAdjtdrjd7oL77h+V3U1gyNgwDENTTHYrGLndbojFYmxubtLwOHltsRiuu3nQ9ZKUEZlMBrPZTP+/uroaAoEAsVgMy8vLVGWDdGt8HtGsgjZe4/E4HA4HLl68iF/96ldgs9ng8Xi0KUGxdMR52szPz+OnP/0p/H4/7VF+N3g8HnQ6Herq6lBTU1MQ4b2nCRHOJidClUqFvr4+dHV1FU0HmCfB7/djcXERH3/8Mc6fP39HZxOhUAidToempqaC8QQ9TUixRE1NzV1/Tr5/i8WCDz74gP6fVCqFyWSCXq8vCmmjF01ZWRkqKyshFArR0NAAhmEwNjb2XLroPCxEizWdTiMWiyEUCiGbzSKfz+ODDz7Ahx9+SLux1dTUPJbxSjZnhUKBf/zHf8Tw8DA++ugjZLNZpFIpOBwOfPrppwgEAjhw4EDBePSJugBRY9lezJbP5x9odGUyGYRCIczPz+Pq1at31FQUO7sjkeR74/P5OxoShEIhXLt2jXb1JKlpe1mpRCQS3VfXNh6PU2cB8I129vNwHBWkNZPP52lP4mvXrsFutyOfz9MWllqtFhKJpCAEsx8H8uBvD/MzDEPzTgg+nw8+nw/ZbHZHHgqRLdnc3EQ4HEYqlbrrYmIwGPD666+jra1tTz5c0WgUDocDwWCQVtN3d3c/0yTxQiCTySCXy8Fms+Hy5cuw2WxIp9O04p6E+RoaGnDkyBE0NzcXVXHWo3Kv+9quy8kwDPUg6vV6dHV17fDWlrg3RNg8EonAbrcjEAjQnLdCgcVi0cK7jo4OxONxKqtIPIy7K6kfl62tLdp9arsBz2azadeqQkIqlaK5uRktLS2w2+3IZDLw+XyYmpqCXq+HXC6nur3bnyXy/ASDQVpTEY/HaU1FRUXFnqqhuBu71xYScu/o6IBarS6qFsGPy/32DdLBkcwJoVAIs9kMuVz+zK+rII1XUi06MjKCn/70p/D5fMjn87Q6eN++fUXvdd3d/Wprawurq6tYXV2lP//Vr36F8+fPU1kWAjk1P+j+W1tb8b3vfW/PFi653W5cu3YNyWQSHA4HjY2NtC/zXiaZTCIcDuPChQv4n//5nzvkTEjSfH9/P370ox+hpqZmz3ldHwbSazsejwMADWnV19fj5MmTEIvFe/K5eNrkcjlEo1E4nU5cvXoVmUwGarW6oFqDEo+6RCLBm2++Cb1ej2w2u0M2bndNwOOSy+Vol6rdaToajeaZCrM/KiwWCwqFArW1tTh9+jQYhsHg4CBmZmbw5ZdfYmNjA++88w7a29vvOOAST/bc3Bz++7//GysrK4hEIvR+KysrqcD/y4RKpUJjYyNaW1v37N76sJCDHNl/VCoV9u3b91waAxWc8cowDILBIOx2O2ZmZhAMBpHP5yEUCtHY2Iienh4olcqinTAsFgsajQZdXV2Ix+PU08owDObm5miuCMMwsFqtiEajNHeLsH0Rvts4iMViqNVqaLXagq56fFyIyoDL5UI8Hqd5SgKBgAqF72Xi8TjW19cRCoWQTCaptAkR2W5qakJXVxf27dsHiUTy0m0uhFgsBqfTCY/HA+C2V0Cj0UClUhV9TjTDMFRfkXh/qqqqnuo9kdzIeDwOq9VKNT5lMhlOnjyJ7u7ugvI6kXWupqYGra2tMJlMWFxcxObmJu29fvPmTZhMJiiVSohEIlRVVT0w75mkIiQSCYTDYayvr+PatWuwWq07ImLA0+mU+LQh64Jer8eBAwfgdDphsVjg9XqxuLiIqakpCIVCCAQC8Hg8ALfnl8/nw8rKCoaGhmC32xGNRsHlciESiaDRaNDW1gaDwfDSFE2TDlvJZLKg9W2fJ+l0GsFgkCoREO/985gPBWW8EqNseHgYP/vZz2hHIalUCrVajb6+Przxxhv0AStGWCwWenp6wOFw4HA4dlTw/f73v8cf//hH+uXncjkalrrbZLjXJKmrq8O3vvUt9Pb27slFxefzYW5uDnNzcwiFQrTrR21t7Z4pSroXRHvv5s2bcDgcO+RuSBHBqVOn8KMf/QgKhaKge48/a9bW1nDu3DlaGa3RaHDo0CHs27ev6L2uDMNgZWUFFosFYrEYHA4HbW1tT9V43draQjKZhN1ux29+8xsqmdPf349//ud/hkQiKbg8ehaLBZVKhZqaGqpGMTo6ikQigU8//RRjY2PU6HrttdfQ2dlJpdXuRSQSwfXr1zE/P091Th0OB5VUKgZIs5O6ujpYLBbcunULVqsVU1NTSCQSsFgs6O7uRnNzM7LZLHK5HD799FO8//772NzcRDAYpDmg3d3deOWVV9DX14fGxsY9nZK0HZFIhIGBAYyPj2N+fh5+v/9FX9ILJxqN7tA6fp4U1MpDcmxIIRLxSmq1WvT29sJsNtOTcrFCwlv19fWora0Fl8ulOa0kZ/FuRundFgdirBB5KLVaDbPZDIPBgP7+/gfKYBQr4XCY6nUCtz1q2z0A21My8vk8rRIudsj9eL1ezM3N3aG1KJPJoFQqUVdXB5lMRqvtXzZIWo3P54PNZqObjFgshlarLbicxEeBYRiqwjI3N4fx8XEYDAYoFAo0NjY+0meRkDcpOCKQVIt4PI5AIACLxULzyo8dO4b29nYaLi7E+UVym9va2qjHdGNjA/l8HqFQCKurq8hkMqisrEQkEoFIJLqvHqXD4cDNmzfhdrvhcDiotivxulZUVKC6uhoGgwFtbW0wmUwF6YEla2BHRwfOnDmDsbExLCwswOv1YmlpCalUCl6vl6oLLCwsIBwOo6ysDAqFYsf9kc50L4vhCnzjwc5ms/D7/QiFQshkMi+lYgk54JBxIHUFPB4PNTU1z8XBWFBWYCaToSf9paUlGhrv7+/Hj3/8Y+h0uqKXe2KxWFAqlRAKhdBqtRCJRIhEIg8tGL0dLpcLoVAIuVyOuro6HDt2DN/73vdQVVVFdU4LcRF9UiwWCz7++GOsrKwAAA2HkS5U29vmZrNZsNns+3pWigVywBkaGsL7779/h9fHbDbjwIEDGBgYeKmLkYjxNTk5iS+++II+W2q1Gv39/VAoFEW7hhDPu8fjwR/+8Ad88cUXePPNN2kXqEeBPB9+vx/Ly8t0vbVYLBgdHUUgEMDMzAzYbDaEQiHa29vxt3/7t1Cr1bTRRSGOI+lM19PTg66uLmQyGVitVkQiEQSDQfh8Pty6dQuffPIJfe391smtrS2k02m6rgA7dUL5fD5aW1vR09OD06dPg8/nF6SDhRhZR48eRXt7O37+85/D7/fDZrNhenqajgM5+BM1grq6Ouzfvx8DAwN4++23qUZoMUpDPQ2i0SiWlpbgdDoRj8fB5XKLOhr8OKRSKfj9flgsFng8Hvo8SKVStLa27lBpeFYUxBNGHhKfz4fV1VU4HA7k83koFAqoVCqYzWbarWEvPCykSrOlpQUnTpzA2toaAoEAvF4vNjc3H/pzZDIZ2tvbodPp0NjYiP3790MgENAe1XvRcAVAdRVJ0Vp5eTkqKipor+V4PI6NjQ36+mLtwkYgm8n6+jrW19dht9vpZgrcPsRwOByqf1xbW1u09/o0yOVyiMViiEajSKVSNCeYzJNify6IEUX6ia+trYHNZmN0dBSpVOqOHu3ES0JUKFKpFOLxOPW4ulwuLC0t0deTdrukMKu2thYmkwkmk4lqKBeD4ULy/Xt6ehAIBGjXLa/Xi1AohHQ6jXQ6TcfnXuwu9CL59aR1qkajwf79+9Ha2goul1uQhiuBNC0Qi8Vob2/HyZMnYbFYYLVaEYvFEIvFUFVVRWXoJBIJ2trasG/fPnR1ddEc+pfN0wjcbvojlUrB5XKRTCZpR7e9rLZwL0hK0fZ9iMViUTnT5zEmBfGUkargDz74AL/4xS9oOPSVV17B6dOncfjwYej1+oJfLB8GsnhUVlbi7bffxpEjRzA2NoaVlRV88sknGB8ff+jP6unpwTvvvIPOzk6YzWa6OZHf87JA7nt1dRV8Ph8jIyO4dOkSxGIxVCoVXnvtNbz66qtFOybE4/qb3/wG77//Ptxu945CEalUCo1Gg9OnT+Ps2bMFvXk+D0ihFumARCBi7cVuvBKId+zGjRsYHR3FxYsXIRAIcPjwYZhMJmpw+Xw+bGxsUKNkbm4OIyMjNA2F/E0+kxTkxdpJMgAACGZJREFUGI1G9PX1obOzE6+++irVtiTh00KHeFWPHz+Oo0ePwm63Y3FxESMjI5ifn4fT6YTD4UA0Gt3R+vJBCIVCdHV1Qa1Wo6urCw0NDTh48CD1wBX62JAGHn/1V3+FgYEBXLp0CYODg5iamsL8/DwUCgVNDyAe5dbWVnr4e1nh8XgwGo1QKpUIh8MIh8OIRqNgs9lgGKZo95fHIZVKIRgMIhqN7rhv0pb7eaSsFcRMTCaT2NjYgMfj2bHhCAQC6PV68Pn8gl8QHoXtHYIAoKWlBVKplBYf+f1+RCIRxGIxxONx2s2CtLcjm1JLSwv0ej1EItFLefojBINBOJ1O2o/a7XaDzWZDJBLtiWpYcrgj7Qp3p5jodDp0d3dDq9W+9NItwG3PazKZpN400jZYKpXe0TWn2GCxWBAIBKipqaF6psFgEMlkEgKBABwOB9FoFKurqzR1hrQwra6upmMikUioMS8QCHaE+UiBbG1tLV1jiEexGD1uxIgVi8UwGo3UQPf5fAgEAlT1JRQKwe/3g8fjQSgUIpVKIRaLUaOdy+XSdbi+vh4ymQxtbW00x6+ioqIonj1yjcQD29bWhlQqBbVajY6ODhrx1Gq1MBqNqK2tpSo4xXB/zwoS5SMFwvF4HHNzc2hqaqJtZ18WysvLaZMG4BsZQhKReB6HnBduvDIMA7vdjqGhIUxPT2N9fZ0aZ3K5HA0NDRCJRC/4Kp8+LBaLCn3L5XIwDIPOzk54PB5cvnwZs7OzGBkZwfLyMurr69HW1obe3l709fUBuD1uMpmMhsRfZpaWlrCyskILs7q7uzEwMICBgQEcO3YMPB6vaBddhmEQCoXg9XrhcDjuWuF65MgRvPfee3uyi9bjkM1madgbAA3tdnZ2wmQyFe1cAG6vGzU1NZBKpfjJT36C73znOxgZGcHa2hq9r+npaYyMjCAajSKRSEAul0OhUNBCNr1ej+7ubvB4PPD5fJjNZrS2ttLfwefzIRKJdqRZFGp+66Mgk8kglUphNptpD3uSNpDNZmG1WnHlyhXodDqYzWYEAgFYrVbqiSaRHLJJk8Kw7Z7oYhojkm7U39+P3t5emh6xXe6I3Ntech49LiQNhRRH2mw2/Md//Afee+89mM3movrun5SqqiooFAraGKS6uhpqtRoajQbV1dXPZR96ocYrqbL3er2wWCzw+Xw7covIiXmvTortiwMAKq7f1dVF86laW1thNBqh1+vR0dEBpVJJ38/j8V7K/COlUknDWKlUinpFSOtHs9mM9vZ21NXVUY9IMRMMBrG8vIyNjY0d+r5SqRRCoRB6vR4ymeyl1XPdTTweh9PpRCQSAYvFgkgkgslkQm1t7Z54VoghSYqmOjo6aItchmHA4XCgUqmQTCaRSqUglUqppil5TogaRVVVFZRK5Q7PEVEv2WtGC7kXMgeIJ43kEGs0GnR3d6O2thYKhYJGvMhazOPxIBaLabvVYkmfuBe7958SD4ZEPhobG2nUY6/aJ/eDeKClUilkMhlUKhWampqgVCqf27rxwnZ1IrIdCoXw+eef47e//e2O1qgvI8QTq9FocOLEiTtOwrsnxcsaxmltbcW//uu/4tKlSxCJRNDr9TAYDOjt7UVbWxsNE5OwaDGTz+dx5coVfPDBB5iZmdnxs8OHD6OnpwcnTpyAWq0ubUL/h81mw+eff47l5WUAQFtbG06dOgWj0fiCr+zpQYxX4hXcfujf3vWJvHb3v7f/vduAeVnWFdKXnsDn82lnICK519zcvGM8itHDWuLpQOaBSqXCG2+8AZfLBavVCq1W+6Iv7blDvPadnZ145f+3dzcrjYNRHMb/wTYYW+1XpFpqa42aFgpqQRGpsxBcufYevAAvytsaNy4UMVStqKWzGJIxM+OoOBqTPL91IOG0SU7ej3O+fVOr1VKv19Pa2tqnLZ+JdEjq7u5OnufJ8zwNBoNQz+RMJhNsrkjLg+L3kQH8nWVZsm1b3W5XnuepVqup2WwGNTz96c6kvIRvb291cXERdHTxZySq1apc19XMzAz/mSf8ETX/t5+YmJBlWYmLEc+L93v6fPDvK+BfpqamtLS0FMxmfKV2wJ/Ff7fatq2NjQ01Gg05jvOpSzwjTV79OoJnZ2caDofBaEGhUFCpVFK5XJZpmowoIcTviGPbtvr9fmhU+umUYFIMh0NdXV0FH3eWZSmfz2tra0v7+/upqzH4klKppFarpcvLS52enkZ9OQASpFgsqtfrBVU6kry08SXLy8s6Pj4OvYM/KxaRJq+j0Uj39/d6fHzUeDxWNptVNpuV4zhyXVfNZpPkFX9I24hToVBQvV7Xzc2Nrq+vValUVK/XNTc3FzSjwC+Tk5PBZsZ8Pq9cLhfUPwaA90jaWvD38GfJIzl3JGd9xuzsrObn53V0dKSDg4NghC2tXzWAYRja3t5WJpPRycmJzs/Ptbe3p36/r263G+uyTx+lWq1qZ2cnaFbgum5iq5YAQBpFmrzmcjnVajV1Oh0NBgM1Gg2Vy2WtrKwE6/j4wkGa+VUF2u221tfX9fDwoE6no9XV1cR0nPvf/B30/o5gx3E0PT0d+817AICfIkteDcPQ4uKiFhYWtLu7G7QvNAxDpmnKNM2oLg34MgzDCDajbW5uajQayTTN1He7+ZdKpaJisah2u63Dw8NgVzkfwgCQDJG+/fw1rgCe598naW9G8VrsGgeAZDOe1gN88WDDOJf0/eMuJ3LN8Xg8+9qDUxAP6Q0xIR5hxCOMeIQRjzDiEUY8wojHn1IQk2fj8abkFQAAAIgSi8AAAAAQGySvAAAAiA2SVwAAAMQGySsAAABig+QVAAAAsUHyCgAAgNggeQUAAEBskLwCAAAgNkheAQAAEBs/ALtVHaBihElIAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 864x864 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     -         0         -         -         -         -         -         -         -         -    \n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x864 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     -         -         -         -         -         -         -         0         -         -    \n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x864 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     -         -         0         -         -         0         -         -         -         -    \n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x864 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     -         -         -         -         -         -         -         -         -         -    \n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x864 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     -         -         -         -         0         -         -         -         -         -    \n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x864 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     -         -         -         -         -         -         -         -         -         -    \n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAq8AAABKCAYAAACVd72FAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOyd6XOb13n2LwAkdoDYCAIgSIIguIGLuIqUKMm7FDt27DaNJ5NM0zb50MlMv7Z/RGfa6aTTmeRD2sZO3GQ8sRPHjhzLliVqIcVNpLiTAEgAxELs+768H/SeY0K7ZEkEZPxmNLLFh5jnOTjPOfe5l+tmFItFVKlSpUqVKlWqVKlSCTAP+waqVKlSpUqVKlWqVHlQqsZrlSpVqlSpUqVKlYqharxWqVKlSpUqVapUqRiqxmuVKlWqVKlSpUqViqFqvFapUqVKlSpVqlSpGKrGa5UqVapUqVKlSpWKoeZhLlYoFEWdTveEbuXw2d3dhc/nYzzo9c/6eADA/Py8r1gs1j/ItdXxKKU6HqVUx6OU6niUUh2PUqrjUUp1PG7nWR+Te9lkD2W86nQ6zM3NPZ67KkNGRkYe6vpnfTwAgMFgWB/02up4lFIdj1Kq41FKdTxKqY5HKdXxKKU6HrfzrI/JvWyyatpAlSpVqlSpUqVKlYqharxWqVKlSpUqVapUqRgeKm2gSpUqVapUKWdIy/NMJoN8Pk//jc1mo7a29jBvrSwoFAooFovI5XIoFApgMplgsVhgMplgMBhgMB647KPKN5RCoVDyBwAYDAZYLBZqap6OWVk1XqtUqVKlyjNDPp9HLpfDZ599hvPnzyObzaJQKOAf//EfMTAwcNi3d+gkEgnEYjHMzs5iZmYGw8PD6OjogFKphEQiAZPJBJNZDcpWuTvRaBQejwd7e3tYXl4Gn8+HRCJBT08POjs7n8ohqGq8VjlUiJekWCwin8/T/wdAF9GqN6BKlSoPQrFYRCaTQSqVwurqKqanp5HJZFAoFPC9733vsG+vLEilUgiFQlhfX8f8/Dxqa2vB4XBQW1sLLpeL2tpa1NbWPjPrbrFYLNlfDnoLHwYyHuQPi8UCi8V6AndcfhBvfT6fR6FQQCgUgsPhwOrqKpaWliAUClFXV4f6+np0dHQ8lXlTNV6rHBrkRUin08hms9jY2IDNZgNw03Dt6+uDUqkEn88Hl8s95LutUqVKOZPL5ZDL5fDpp59icnISU1NT2NzchFQqhUQiOezbKwuKxSJMJhO++OILTE1NYWZmBhsbG/jwww8xMjKCnp4ejI2Nobu7GxwOBzwe77Bv+WtRLBYRj8eRSqVgNpvhdrtx9epV2Gw2ZDIZZDKZB/oMAFAoFFCpVGhsbER7ezva2trQ2tr6jfBURyIReDwerKysYGFhAXt7e9jZ2UEgEIDP5wOTyURtbS14PB7GxsZQU1PzxNMHqsZrlUOB5FzlcjlEo1EkEgmsr69je3sbAMBisSCVSmku1q15WVW+2qzJ+HwTFtEqD04+ny/J+bzVcwTgvu/Sg1532BCPazqdph7X3d1dRKNRSCQScDicb4yX7H7EYjG43W44nU6EQiEEg0EAN7/jfD4PmUwGlUoFiUSC2trail1XiMc1Ho8jHA7DZDLBZDLh8uXLWF5eRiqVQi6XK/kdBoNBDa9CoVDirVWr1Whra4Ner0cymQSPx4NGo0FNTc0z5ak+CPG4hsNhOBwOLC0tYWpqCnt7e3A6nchkMshms/R6v99Px/1JUzVeqzx1SE7axsYG7HY7zp49C7PZDKfTiVgsBuDmIvLFF19AKpViaGgIBoMBJ06cQFNTE2pqar7xG1GxWMSVK1fwwQcfoL+/H0ajEXq9Hg0NDYd9a1XKhM3NTUxPTyMSiSAej0MqlUImk0Gj0UChUEAgEEAgENx1w2WxWKitrQWLxSrryAc5xJ09exZTU1O4dOkStra2kEqlwGQyYTQa0dPTA7lcfti3WhYoFAoYjUbs7OxgZWWFGigWiwUejwebm5v49NNPMTIyghdffBEqlQpKpbKijLNisYh0Oo10Oo333nsPc3NzsFgs8Hq98Pv9SKVSt6UO8Pl88Hg8DA8Po729neZ0RqNRRCIRMBgM2O12OBwOXL16FVNTUzhy5AgGBgZw7Ngx8Pl8CIXCihmje0GMz2AwCK/Xiw8//BAfffQRPB4PgsEgHdunYaTejarxWuWpQjyu2WwWdrsdKysrmJycxNra2m3XWq1WMJlMpNNphEIh6PV6KJXK27xI3zTIyXZ9fR1nz55FoVAAm81+IMOVeBGIR454sr/ph4FnjWKxiP39fSwsLCAYDCIYDKKhoQEKhQI+nw9tbW2QyWSQyWR3/Qw2mw0+n0/zIRkMRtl54Mh6kk6nsbKygitXrsBisSASiaCmpgZcLhdKpRItLS3g8/mHfbtlgUAggEajgUQiAZ/Pp+HzWCyGWCyGcDgMs9kMNpuN5uZmcDgcyGQyGv2qlDU3l8shlUpha2sLly5dQiAQQDKZLLmGzGkGgwGxWAyJRILW1lYYjUYIhUJwOBxEIhEEAgE6PtFoFOFwGOl0GslkEgwGA0ajEUwmE0Kh8JCe9vFC9phwOAy73Y61tTVcu3bttuvI+JG5UVNT89TmR9V4rfJUyefzWF9fh9VqxW9/+1ssLS1hb2/vjtcSQ2tpaQlmsxlWqxVarRbf+ta3MDQ0BKlU+swsFg9DMplEIpGA1WqF0+nE/v4+XC4XUqnUPX8vn88jm81ie3sbv/zlL9HQ0ICRkRE0NTWho6Oj7AyTKo8G8URaLBYsLi5SbwmPx6MGqUgkAofDoQYdkUwiFAoFKBQK6PV6tLa24vjx47Qgo5yMl2KxiO3tbZjNZiwsLGBzcxPxeBwMBgOjo6Po6OjAD3/4Qxw5cuQbuVbcCoPBgFarRX19PbhcLlpaWnD9+nUsLCwgHo8jmUwinU4jn8/j/Pnz2NjYwPj4OM6cOYOWlhbodDrU1NSAzWYf9qPcl0KhgGw2i1QqhUQiQQ/sB2EwGGhqaoJGo8Ebb7yBEydOoKGhARKJhIbESfoNST9YXV3F/Pw87HY7rl+/jmw2CyaTifHxcZw6deqpykU9KciYffTRR3j//fexs7Nzx+skEgmUSiV0Oh30ej0mJiaeWiHbEx1hYr3fqbLvTp6zcloUy42D7nkyrrfmlhz0jJRrrlqxWITX68Xm5iZu3LiBzc1N+jNyqr914kciEQSDQUQiEQiFQiiVSmi1WlpQUI4eoSdJJpNBJBKhucKxWOyO+Vu3Qt5Fh8OBP/7xj+js7KSh4fb29qd09w8OmdskrHm3teJu78Ot3PpOHPy7XN+XR4FstqFQCC6XC7FYjBat1NTUwOfz0TEtFAq3jSX5W6VSIZVKIZ1Oo7W1FQAgl8vLKu+8UChgf38fq6ursFqtCIfDAG5GFLRaLdrb26HT6aBQKA75TssHHo8HHo8HvV6PaDSKYDCInZ0dMBgMOi+KxSLNi2Wz2VAoFGAymVCr1QBQEcYrgRQT3WpUkX/TaDTQ6/UYGRlBX18fOBwOOBzObZ9DDDqBQIB4PI50Oo1oNAqr1YqNjQ0oFAqMj4+DzWZXvPFK9hiTyYSpqanbfk4MdIlEQg3Xnp4eqNXqp7Y+PLERLhQK8Pl89KTicrkgFotpCIrFYsFgMEAmk9FkevKzKqWQanziUfH5fHA6nXC73djb26MThUwggUBAk+3LLVeNhGcaGhpKKllZLBZOnDiB5uZmmo9HJE0uXbqEGzduIJvNwu/348MPP8TS0hKOHTuGiYkJ6HQ6qFSqii0seBiKxSLMZjMuXbpEDf+6ujqoVKr7VgaTTSmdTiMYDMJms8FsNkOr1T6NW38oisUiIpEIEokEzGYzPB4PamtrUVNTA5VKBaFQSA87xPu8srKC3d3du36mSCRCXV0dFAoFtFotNdzJ5kWqZSudbDaLWCwGr9cLj8eDl156CUeOHEF3dzfa29tpmNhqtcJisUAoFEImkyEWiyEQCAC4Of5yuRx6vR6BQACff/45Ojs7oVAoSg6Nh/2c2WwWy8vLWFpags/nAwBwOBxwuVwMDw/jzJkzqK+vP9T7LFe0Wi3kcjk0Gg2MRiPC4TCi0ShisRgikQjW19dx/fp1rK+vIxQKYWdnB8FgEL29vejp6Tn07/9eMBgM8Hg81NbW4oc//CH6+vqwsLAAu91Of3706FG0tbWht7cXDQ0NkMvl4PF4d/Ua1tbWQigUorOzExqNBgMDA+ByuXC73bh8+TLS6TSEQiF6enowMDBQkXsRObxsbm7eMZ2PyKodP34co6OjMBqN6Ovro/m+fD6/8o3XYrGIUCgEp9OJK1euwGaz0RwboiNHTickr+pxedCeBU/KQU9SNpulJ710Oo3d3V0sLi7CZrNhY2ODjltfXx94PB6USiVqamrA5/NLclDKxUNJjGqySJCTsU6nQ1dXF5qbmyGVSmnYZ29vD2azGZFIBKlUChsbG9je3qbGhkAggEKhQE1NTVk835OCzAePx4P19XW43W4AN70gIpHogU77pCo7mUzS/LZYLHaoifd3glQJBwIBXL9+HVarla4bXV1dUKvV1JOyuLgIi8WCixcvYn5+vuT9P/hccrm8pGKYVAn39vZCoVBAJBKBy+VW7JpByOfz9DtOJBJQKpUYGxtDX18fmpqaqNHX0tICtVoNsVgMuVxODV6CUChEfX09dnd3cfHiRYhEIqRSqbLIjz6Y6+rxeGC1Wmk+I5vNBo/Hg1arRWNjY0V5CZ8mxANL5J5IWNzn88Hv9yORSGBlZQXhcBjBYBBsNhv19fWQy+Xo6uoq+/xX4iTT6/UQCASIxWJ0jWQymTh69CiMRiMaGxshEonu+3lkvSFGbDqdhtFoRDabhdvtxtraGhobG8Hj8dDf31+RNRmkHsJms2FlZQUul6vk5xwOB2KxGHq9HsePH0dHRweam5tpzuvT5Il6Xr/44gtMT0/jxo0b8Hq91J1OJv309DSkUik1XtVq9dcK77DZbNTV1aGpqYnq1N2rmrZcIaE6u90Om82GtbU1WCwWxONxJBIJBAIB+P1+WgUJ3HwZbTYblpaWIBKJIBaLUVdXB41Gg7q6Ouh0Omi1WhiNxkNddAqFAjY2NjA/Pw+v1wsmk4kjR45Ap9PhBz/4AYxGIzVSiLFWX1+PF154AX/+859x7tw56omemprC7u4uzGYzjh8/jsHBQRgMhopcNB6EZDKJVCqF5eVlzM/Pw+PxALjpUdRoNPf1sqdSKdjtdlit1rIzVgnEuM5mszh37hwWFxextLQEh8NBNw+yZhBPezAYpIauRCKhf0iqCYHFYiESiWB1dRVmsxnATUNvamoKn332GU6dOoW3336bzr9ngTu9B0RyjuT2MZlMKg2k0+nodeTf+Xw+vv/970OhUFD5usN+v/L5PM6dO4fZ2VmcP38eJpMJsVgMDAYDR44cQVtbG7q6uiASicrC2C5npFIpjXSRg08mk0F3dzdkMhlVrdjd3cUf//hHRCIRWvTV0tJy6HPhXjAYDDQ0NEAmk6GxsZHWBTAYDEgkEnC53Ic+3JDnbWhowPe+9z3odDrY7XYkk0lcunQJDAYD/f39kEqlUCgUZT0+BykWi9jZ2YHJZMLZs2dx4cKFEhk1BoOB733ve3j77bfR1NQElUpFnVCH8YxP1PO6s7OD2dlZmnd1qzdka2sLwE1rns1mQ6vV0pwJwr06Ydx6nVgshlQqhdFohEajgVgshkAgeBKP99g5mGuWTqcRiUSwubmJ2dlZLC0t4fr164jH47QY4aA3lbj6vV4vTCYT/blEIkFLSwu0Wi26urpoG8DDrC4vFotwOp3Y29tDMpkEk8lES0sLWltb0d7eDo1Gc9vvdHZ2or6+Huvr6xAIBNTAcblccLlcYDKZ1MglXoRnbcMi8yIUCtF0kXg8DiaTCS6XC4FAcF/Pazabhc/nQygUAnB7x5hyIZfLIZlMYmVlBVevXsXW1hbNZbw175XJZILNZoPNZoPD4dADm1qthsPhuOPnEw8j6cRkMpkwPz8PPp+Pt956i0YCnlXIukk8b/eDwWCgra0NAoEAbDa7LKIbhUIBs7Oz+PTTT2E2m+n8YLFYaGxshF6vh0QiqXpdHwAul1ty8CXpWul0Gk6nE+l0GvPz84hEIvD7/ZDJZOjp6QGLxUJzc3NZrR23QtIHeDwexGLxY/1sovPa3t6OlpYW2Gw2bG5uoqWlBU6nEwwGA3K5vKzH5yDFYhEulwvXrl3D6uoqbRhE7IXa2loYjUYcO3YMbDb70FMSn5jxymQy8Z3vfAcGgwE2mw3RaBQymQx8Pp+GJHw+HyKRCKxWK/Um+nw+CAQCCIVCWpByK2SzJZ7VZDKJeDxO9QgjkQjUajU6Ozupp6CcSSaTyGQysNlscLvdWFhYwO7uLqxWK+x2Ox0nNpsNuVwOlUoFrVYLkUgEgUCAjY0NzM7OQiwWQ6VSIRwOY39/nxo7+XweiUQCmUwG7e3tkMvlaGxsPJRNiFQHT01NIRwOo6amBuPj4zh58iSkUukdf0cgEIDD4eDtt99GR0cHrl27htnZWbjdbng8HppSkMvlEIlE0NPTg7a2trIzyh4VUoAzPT2Nc+fO4dKlS4hEIjAYDGhtbcWpU6fQ0dFxxyKDgySTSZhMJng8HnrYMxgMaGpqekpPcn/y+TyWlpawtraG+fl5mM3mu64BJ0+ehMFgQFtbG9RqNfUkEmP2bh10wuEw3G435ubm8P777yOdTtP1yOFwQC6Xo6Gh4ZmYO4/Dw15bW0tzystlTEj6DIlIAaAHmKGhIbz88stVXddHhBwKGxsb8dZbb0Emk8HpdMJqtcJkMsHr9WJpaQlyuRxDQ0MAUBYHmqcNGSexWAyj0YhisYjp6WlYrVZcvnwZo6Oj1JlS7pB6GpPJhJWVFezv7wMAzWMlSgzj4+Pg8Xhl8UxP1HjV6/WQyWRwOBwIhUJoamoCn8+Hx+OBz+fDzs4OvF4v8vk8kskkDfMVCgUa4iNeooOQLhjEaxCPx0tytXg8Hvr6+iCVSss2PAqUFtBEo1GsrKxgcXERU1NTtAPIwc2Xz+fTFIC2tjZafJLNZjE/Pw+hUIiWlhbs7e1hf38fhUIBmUwGwWAQ4XAYIpEIm5ubMBgMd/RwPq1n9vv9VB5LIBCgo6MDer3+rsYXqf5sa2uDVCpFKpWiByAiA0SkgFgsFoRCIfR6PYDKzXk+CAnnLS4u4pNPPoHH40EqlUJDQwM6OjrQ0tLyQF6FTCYDr9dLG0Hw+Xw0NDRALBaXxTiR3tk3btyghispIAK+0qQl77/BYMDo6CiGhoZKdCvvRyKRQCgUAoPBwNmzZ2lxWCwWg9/vB4/Hu03doNJ4nF1unkarx4elWCwiFouVhDVJ0a9er0dLS8t9D3NV7gx5x0gTi66uLrS2tiKTycBisSAWi8Fut8Pj8ZT1/vo0IE40rVYLh8OBXC6HYDBIZR0rBdI4iDiDSKScy+Wirq4OQ0NDOH36NOrq6somKvXEViQGgwGpVAqRSASlUolcLgculwsmkwmNRoNcLofx8XFqXEUiETgcDni9XjQ2NkKlUsHhcNyWMAx81fmFVK1PTk7i5z//OdLpNFKpFN2U6+rqynYDKhQKMJlMsNvtWFhYgMPhgNlsht1uh9vtRiKRgEqlQn19Perr6yGRSDA0NISjR49CKBRCKBTS3DzifR0dHcW3v/1tLCws4P3336dVo+Qas9mMX/3qVxgfH0dnZyc4HM5TFRUGbs4LnU6H/v5+7O7uIp/P0+K9+90HKfZ74YUXoFar8fHHH8PlciGbzVLPdTqdhkwmg8FgoLmPlQzxMLndbmxtbcHj8SCRSIDBYKC1tRXHjh27p9D8QaLRKNbW1qhmn0AgoJX7hwkpSrx+/TrMZjM+//xzrK6uIhAIlISsTp06haamJvT29kKr1VKhfbFYDDab/cCLKpvNhlQqhVqthlAopIU+RKC8XIz5RyWRSMDv91OP5LPMwUMGydElEb6HNbjJOkLC5veDOFCelQjP3WhtbcU//dM/4Y9//COuXr2KSCSC5eVl9PX1IZfLlU0h8GEhEAhgNBrhdDorchwKhQKuX7+OmZkZTE5Owmaz0ZS+8fFxDA4O4ujRo5BKpWVjuAJP2HglntH7VfIRIeBQKIRQKIT6+noIhUKaY3MrBwsJyGe/8847yOfz9CREkrHLlWKxSDt/TE1NYWtri1bTAzfHTyaTob29nYZET58+jZ6entskoXp7e6HT6WA0GjE6OgoOh0NFlA96pL1eL1ZWVsDj8ZDJZA7Fo8JgMKBUKtHW1kaNdFKIcye9yYO/RwyUxsZG8Pl8rKysgM/nIx6P00NQMBiE2WyGw+EAk8ks6wPMg0BymVdXV+FwOEoK9Orr66HX6x/Y+Ewmk7DZbNRjQt6Tw5aHIpXjV65coZEHErYi3zuXy0VXVxeOHDmC559/Hg0NDbSa+GG/XzLvyQGQvAM8Hg9SqRRsNrti5wyJ5JAOQJX6HA/CrWsE0Z7k8XgP5XUln5PL5ZBIJGgHwPtBmj4cXI+fxfEWiUTo7u6mWrDJZJJGSvP5fNmn5T1pamtrqZOpEr//YrGI+fl5/OlPf8Lq6iqCwSCtG2lpacH4+Dg0Gs2h7xO3UhaxILIB1dXVQSAQ0A2FSNfcCQaDgXQ6jf39fezs7CAajaKmpoYWJw0MDEAqlZbVSYic6ImH+S9/+QumpqbgcDgQjUbBYrFQV1eHvr4+6HQ6HD9+HAMDAxAKheDxeFQo+tYXJJfLIRwOI5lMolgsoqGhAW+++SYWFhawsbFBu4vkcrlDD/OQJHZSqXhrPmOxWEQgEEAoFILD4cD+/j7N0yUQCSC5XI4XX3wRy8vLJXp0yWQSbre74nPeyHe2sLCAc+fOYXt7GwDw4osvwmg04syZM2htbX3kQxo5HB2mgZ/L5bCzswOXy4Xp6WksLi4iHA6DyWSira0NSqUSJ0+eRHNzM0ZHR6FQKCCTyVBbW/vIOZiZTAbpdBoulwsejwfRaPQJPNnhsb+/j5mZGTidzkN/358kX3fOJhIJxONxuN1u7OzswOFwwGazUZmx+0EKlyQSCVQqFUQiEdRqNe1AVYmGzJ2Ix+PY39/H9vb2Mz2fvslEIhHs7e3R/bi7uxsGgwEvvvgihoeHH3ux2+OgLIxXcnK91QtICrDuRi6Xg9frhdfrRSqVglgshlqtRmNjI9RqddktICSnz2q1YmlpCTMzM1hYWKA/J8Z7T08P+vv78dJLL0Gn0923ev5gQVahUEBdXR2OHj2KcDhMW4KmUqmyGAuigkA8XHfC6/VS3U6LxYLnnnsOAwMDt10nEonQ0dGBQCBQYrwSObH7tUstd0iu6+bmJi5evIhIJAIGg4Genh6cOXMGHR0dqKure+jPJBB9XNK3/jAg7YKJ/BdpMsBms6HT6aDT6fD6669Dp9NBKpU+ljzGXC6HaDRKm6ik02kAz47XzO/3Y3t7uyTqQriT8VHJz/117j2dTsPr9WJmZgYXLlyA1WrF5uYmEonEHYsEb0WpVOL48eNQKBTU4UAifof5Tj1uEokEPWASnpVnexwcVAqqVIjUIFkL9Xo9+vr6YDQa0dDQcMh3d2fKwnh9WEj19e7uLn7zm99gY2MD+XweTU1NePPNN3H06FGw2eyyCmeQAoNIJIIvv/yypNsHn88Hl8vFW2+9hf7+fgwPD0Oj0UChUNw1LEpCrfl8HgKBACdOnEAymcQvf/lLpFIpRCIRmM1m5PN5+lJJJBI6IUlXs6e9CDEYDKhUKjQ3N1NtQY/Hg0AggEKhgJqaGly4cAGTk5PY2dmhnrGZmZnbPiscDsPv99NxJFgsFly6dAm5XA4KhQJCoRACgaCiJLQKhQKmpqZw7do1TE1NIRqNUhmonp4edHd3P3C6AAmDBgIBKlsHfBU+P+wxIXJXRI5peHiYavuq1Wpa6Pm4Ulz8fj+++OILzM3NIZ1Oo76+Hj09Pejt7aWpCJXMzs4Orl27Ro2N1dVVsFgsLC0tlei4EnQ6HVpaWiASiR5IrL3SIREwq9WKTz/9FGtra5ibm6NFe3w+H/X19bSJhUgkQn19PS0cTSQScLvdyGazWF9fB4fDgdVqhVwux/LyMurr6zE0NASpVIqmpqayK3a7H6RtcDgchs1mw+LiIs6fP4+trS0UCgVIpVI0NzejpaXlmXhfvi7pdBoWiwVWqxX5fP6wb+drQewBDocDPp9f1t9tZb1V/x/SeclqteKDDz5ALBZDoVBAY2MjTp48icbGxrLrtkQqmt1uN27cuIHz589TzyCp6Dt+/Dheeukl2h71Xp9FvLipVApcLhf9/f1YWFjA7373OyodRjyxBLFYjL6+PhgMhkMzWkh6iEajoZXhJNeZFObMzc3h97//PTW879Xy8054PB5cvXoVIpEIR44coSkKAMr6ZTxIoVDAX/7yF7z77rsIBAJIJpNUFLy9vZ3mfD4I+Xwe6XQagUCgxCNNco0Pe0xIrqJarYZUKsXLL79M2zY+iWIyn8+HCxcuYHNzE5lMBjKZDAMDA+jo6KDpCJVKsVjE/v4+jUQwGAxsbW3B6/VCLBbfMfx3/PhxvPHGG9BoNBAKhc+8V41ENEjnsK2trZI1huhjEylGiUQCrVZLtUKDwSB2dnbgdDpx6dIlZDIZ3LhxA1wuF9PT09Dr9YhEIuju7oZGo6lY49Xj8WBychKzs7P44IMPkMvlAHyVA6vRaMpi/ThsEokEtra2sL+/X9HeVwKDwbitC2Y5Ullv1f8nHo/DbDZjeXkZsVgMuVyOykjJ5XLw+fyyXIBJMwEAJV5PsgD4/X643W74/X6wWCwkEomS0DfJ8SNt/Px+P7xeLyKRCO1VHwgESqpmgZseNi6Xi46ODpw5cwY6ne7QumIQzyufz8d3v/tdHD16FGNjY9BoNGAymVQmjc1mI51OP9JJNp1OIxgM4tq1a0ilUpBIJFCr1Whvb8fQ0BD1MJVblSw5kJjNZuzt7WFtbQ2hUAiZTAYMBgPPP/88JiYm0Nra+lBGFqnmJx26MpnMY5VS+jrU1NTQjkjHjh1DLpejntbHLTBPnjkQCGB+fh5+vx36Qa0AACAASURBVJ/Ox4GBgUOTj3scFItF+Hw++Hw+2O12WoVPvuM7Vc+n02kkk0ksLCzA7Xbj5MmTeO2118Dn8yumuQuByWTCaDRSCcF74fP5YLVaMTU1hfX1dVoE2dDQgNbWVoyOjuKll14Cl8ul3lbSBKSmpgbZbJbmCOp0Ong8HszMzCCTySAcDmNraws1NTXweDx47rnnnsbj35VisYi9vT14PB6YTCY4nU7weDxwuVxotVpIpVL6XGR/8fv9cDqdWFlZwfz8PHZ2dpDNZsHlcqFQKDAxMYEf/OAH0Ov1ZW3cPC2y2SxcLheV9ZTL5ejv76da4+VKsVikKTJEepJ4XNvb23Hs2LH7vkvkIJhKpWjBtM1moy2a1Wo11bp93HttRRqvoVAI165dw/b2NqLRKNhsNl1w71XkVQ6QTeXgpCbh7FAohL29PXi9XkSjUbhcrhKdS1II4PV6Ybfb4XK56GIkEomQSCRop5mDkNCXVqvF0NAQxGLxoRmvRAFAIBDg9OnTCIVCMBgMtFd0KpWiBXskLeJhSafTSKfTuH79Oq5fv06N4TNnzqCurg5qtZpqwpaT8UoWgitXrmBqagqLi4s0xM9isTA4OIhXXnkFEonkobw5JFJBxvdBZICeFiwW66kZjcSj5PV6qWeSyWRCKpWis7Ozolo53om9vT3Mzc1RDeX7GbCZTAaxWAyzs7Pw+/1IpVIYGBhAQ0ND2ToA7gaTyUR7e/sDeeudTifOnTuHpaWlkpSjhoYGDAwM4PTp03jxxRfvq8bS1dUFHo+HtbU1OBwOeDwe2Gw2BINB7O3tPfLh+3FSLBZhMplw8eJFfPLJJ1hYWKASlsePH0d7ezv4fD54PB5Nk1hbW8Py8jIsFkuJR5q0cO/u7sbExAQ4HE5ZrZ+HBdHPDofDKBaLkMlk6O3thUqlKvt3KBqNwuv1IhgMIpVKQSaTQSQSob29HXq9/r6HWLJnBYNBrK+vY2lpCZOTk+Dz+ZBIJHjuueeeWBe2ijJeiVGyvb2NL7/8klY/dnV14fXXX8fo6CgkEklZJsuTQiUWiwW9Xg+Hw4GdnR0Eg0Ekk0lks1lcvXoVu7u7SKVSSCaTCIfDiEajJeLspHkD6T5G2vgBKJF3OdgetrOzExMTEzAajWUhMkyK8xobG6FQKGhuDclTfvnll8Hj8WCz2eBwOJBOp5HNZuFwOEqM+QeFGG/Ly8v49a9/DZVKhd7eXrS0tNA8Rw6Hc+hzhhTXmc1mzM/PlzToKBaLuHjxIkKhELq7u6FSqdDY2FjSlexg4eNBj0gikYDFYqFGzTcVv9+Pra0tzM3NAQAUCgUMBgN6e3up/Folkk6nkcvlcP36dZw/fx4WiwXAzYrhrq4udHV1oa2tDWKxuMSwi8fjiEajuHjxIt555x2sra3ht7/9LSYmJvDCCy+gpqamYoT+iYoLj8e7r1IA6TxIDoaEtrY2nDhxAjqd7oHSzjgcDvr6+iCXy+H1emmHxHIrFCXrCjGkyQH2xo0b8Hg8qK2tpWsvk8mEy+WCw+FAKpWCSCRCY2Mjenp60NTUhP7+fvT09FCN8G8y5DBM2rkDgFarRWtrK3Q6XUXINJJnIJAUGaKBfbfvmKQmWiwWXLlyhXYn9Hg82NjYAIfDoU41ohH7uFvlVtTsIyechYUFfPzxxzQHx2g04oc//CHkcjkEAkFZThgGgwGhUAgOhwODwQCPx0MXUKIteOHChZLrD/43CanfKdSbzWbvqEtIGhuMjY3h7bffpiGwwx4fkiZxaztYFouFYrGI0dFRtLS0YGpqCiaTCbFYDKlUiuZtPiykuM1sNsNsNkMikcBgMGBiYgJarRZisfjQN2myiGSzWezs7GBxcfG2n589exYXLlzA+Pg4dDodXnvtNfT09NBrSJUzUJrbG4vFsLS0BKfTCeCruXXY8+Bp43A48Lvf/Q4rKysoFotQKBQYGhrCkSNHIJfLK9KLVCwWkclkEI/Hsbi4iI8//pimmRw5cgTHjx/Hc889h7a2NtrUhEDWDQaDgXfffRdbW1twu91Ip9MYGRmBQCAoO8WWu1EsFmnBzP2aMxDj9VZFAZVKhZGREcjl8gcyzLhcLpqamiAWizExMQGBQIBPPvnkaz3Hk4AUbBJPfCqVokW96+vrJXvKwe+az+fTOokXX3wRfX196OnpKYu+9uXAQeOVyO0Rw1WlUpWlE+1WSCoVmRsKhQJarRYymeyeuq7JZBJ7e3v48MMP8e///u/I5/N3jOhJpVKsrq7CYDBAJpN9c43XRCJBT7e5XA4ikQgKhQKtra1QKBRlJ6J7K6St5XPPPYfOzk48//zz8Pv9WFtbg8vlgsvlQjgcBofDoV2x+Hw+nVzBYBChUAjhcPiO6QEEpVKJ7u5u9Pb24vXXX4dWqz00dYGHhRR0sdlsqjFHwm8vvfQSFa8HQD2yBOJBJTgcDqyvr8PhcMBisVCVilQqBYfDga2tLVy4cIHKgpDe6Ic5RsS7XlNTU6IUAYDmMa+trcHv9yMWi9EWhKSdo0gkgkqlglKpRCaTQSKRwPr6OhYXF7G1tQXgpiSbVquFRqMp+/nwOCB9u51OZ0mouLW1lRp2lTwObrcbVqsVLpcLuVwO9fX1qKuro7mbpLjvVuOcHHD0ej2+/e1vw263w2KxIBAIwO12Q6lUHnr3tYeByP0cdqi+pqYGEomkLNJQGAwGuru7UVdXB5VKBYvFgnA4jFgsht3dXXpYyWQyJd5Z4OY+MjAwgNHRUZw6dQoSiYTuI99kyJqcSCSwv79PdcZ5PB6USiVNp6iEw7BYLKZd6bhc7n0PbSRNwGaz4U9/+hPW19fv6lQDAKvVis8++wypVArd3d2P9d4ryniNRqNYXl6G2+1GPp+HWCzGwMAA2tvbIZFIHlm0/GlBJnRnZyc6Oztx7Ngx5PN5XLt2DXNzc9jc3ITb7aZ5u6T1Jcn9dDqdcDgcMJlM9zReVSoVJiYmMDY2hpMnT9Jc2UqBtL+tr68HUKqucHBxJWLz5Dtns9klz7mzs4MPPviAGrCZTIYary6XC4VCAXw+H0ajERqNhhrN5WK83rookLQZk8kEk8mEy5cvl/weMV47OjrQ1taGcDgMp9OJSCSCQCCARCKBYrEIqVSKwcFBNDc3H8YjPnVyuRzi8ThMJhNmZmZoxEaj0WB8fLyi28ESNY7z58/DbDYjk8lArVajs7MTJ06cuOeGQdYjrVaLl19+GbOzszSUbLPZaI5jJUCKT4LBIP1+D4va2loolUpIJJJDn1cMBgNNTU1obGxEc3MzTW9wOByYnZ3F4uIiQqEQ4vE44vF4yfpK0gROnDiBzs7OQ3+WcqJYLCIcDmNubg7z8/PY2tpCQ0MDdDodrdIvd+OVRIN5PB6NWt/PeCWNc1ZXV/Hee+/d97DocDjwwQcfgM/n42/+5m8e6/1XhPFKjJdIJAKTyQSPx0NzR0+dOoWurq6K7C9NPKFtbW2QSCQYHh6mnlcSmmGz2dSImZqaQiaTgdvtLvmcg63choeH0dXVhVdeeQUqlaosdDwfFhKCIEY7aQt7p8PJwZft1kYXSqUS3/rWt9DV1QW1Wo29vT1cunSJFrbFYjGsr6+DwWBgamoKbW1tGB4ePpRFh3jli8UiJiYmwGKx4HA44PP54Pf7kUwmb/PE3qpGkc1mEY/Hsbu7i2QyiWg0ilgsRgu1crkcampq0NzcjJGRkYr3OD4o2WwW0WgU0WgU+XweMpmMVpaLRKJDzwH/OjAYDDQ2NmJ0dBThcBhCoRAvvPAC+vv7H7gQTigUoqenBzabraLnA8ntjMfjtPDzYdY+j8eD5eVl9PX1QSaTPfJ91NXV4fnnn0dPT09ZrL0k7UwsFqO2thZisRhtbW3o6OjACy+8QFPXzGYzNjc3sbOzA5vNBqfTiY2NDXR3d2NgYIAeqr/pHCz8/Oyzz2AymVAsFqFUKjE4OEjtkWeRRCIBn8+HnZ0dBAIBmqJDnC5SqRRqtZoeJJ/kXloRM5FMlkAggOXlZdjtdtTU1KCtrQ1nzpyh+WqVNmFI7mdTUxOampruez2DwYDNZrtNq5HFYoHH42F4eBg/+tGPoNfrYTAYKnJMgK9Od5FIBIlEAg0NDXdsOnG/hVQul0Mul6OrqwuDg4NYWFig3utIJIJ4PI61tTX4fD4AwMjICAYGBg5tgSZFIqT96/T0NOx2O9WUPJjbTPQ8DxqvmUwGmUwG0WgUNpvttlw2UhTX3NyMU6dOQalUVuT8eFgymQwCgQAikQjy+TyUSiXGx8fR3d1NVScqGY1GA4FAgEwmA4VCgb/6q7+imrUPgkAgQHt7O1ZXV8tOPu5hOFj5nEgkIBAIHuq7JV39pFIpDAbDI78bcrkcr776Kpqbm8tibhHHDpEIVCqVAEDz5YmTYGVlBZ9//jmuXr0Km80Gl8uFyclJGI1GpNNpsNnsqvGKr+yR3d1dvPvuu9Tz2NTUhBdeeOGZTscKhUJYWlqCyWQq6eBH9pbGxkaMj48jEAjQ1vRPqv12RczEWCwGr9eL5eVlWK1WMJlMtLa2oqmpCXK5HFwu95mdLMDNdIlQKITr169jdXWVFt4Q9Ho9xsfHMTIygs7OTppCUUmQsF8mk6F6hC6XC9FoFC+//DJaW1vB4/EeqbCqtraWypf87d/+LVZXV/F///d/tLd5KpWC1WpFQ0MDgsEgRCLRoUkFMRgMyOVyWq0ZiUSodNqtaRMmkwl7e3u0cxtBLBZDJBLB7/fD5XLB5/Nhf38fLBYLHA4HEokEDQ0NFafl+bCQTkp2ux0ff/wx1tbWUCwWYTQa8d3vfpfqVFby2kE89nw+H/39/WhuboZarX6oJi2kEDYQCNxWfVyuMJlMDA0NIR6P49q1a/B4PFTL+OLFi4jH4xgZGYFKpYJAIChZN5qamvCtb30LCoUCSqUSNpsNe3t7iEQi2NzcxOTkJMRiMaRSKRQKxX0LlPL5PC3AJelN0WiUqsCUO2SeEH1Sk8kEFouFQqFAozskalOJkEM8qZ0g3w2xHQ46ee61FpDPCQaD2NzcxOzsLC381Ov16O3tpQXAlbimFItFpFIpJBIJZLNZFAqF2yLaRMeYOHxI1Le7uxtHjx5FS0sLhoaGsLi4CKvVesdC8sdFRcxGj8eD8+fPY25uDru7u9Dr9RgcHITRaIRUKq3IifIwuFwuXLt2DZOTk7hw4cJtm8vAwAD+/u//Hi0tLWhpaanY8SCFIv/zP/+DCxcuUOHkRCKB119/HXq9/pGMV5ILKxKJ0Nraihs3buDy5cvY39+nBuzm5iYkEgl2d3ehUqnQ1NR0aB3IJBIJJBIJGhsb73mtzWajbQkdDgf998bGRrS0tGBtbQ03btzA6uoqNV55PB4UCgXq6+vLwiv0JCEe/NnZWfzsZz+jXuqenh688sorFXfAuxskpUYqlT6SMR6Px7G9vQ2Px1MWjSseBBaLhZdeeonmcXo8HlqY95vf/AYfffQRfvrTn+L5559HR0dHybqh1WqhVCqh1+uh0+kwMzODzz//HOFwGFeuXIHb7YbZbMbg4CBeffVVepi827gSGT+fz0fTncLhMOLxeEWMJ8l9VigU6O3txfz8PNhsNo1+kW6NlVQ3cSuFQoFKw62trcFqteKVV16BVqul+akPsh4UCgWYzWb853/+J22X29jYiNOnT9PunpUa8QS+KnpMpVLI5/N0PSHz2OfzYXFxETs7OwBAHSJjY2P46U9/Sg+EMpkMn3/++ROVjStr45V0AzKZTJienobFYkFtbS0MBgOVU3qWicfjSCQSWFlZwbVr12CxWEqKeLhcLgQCATQaDZqamipCV+5eHMxZC4fDSCaTyGQyWFlZAQC88cYb1BB9lDxFckpUKpX49re/DZPJhN///vfI5XLIZDLY39/H/Pw8enp60NjYeOjG3f2+S4lEAp1OB7lcjo6ODvrvIpEIQqEQsVgM29vbdOMlndYOuyjtaZFOpxEOh+HxeJBKpagXYGtrC9PT03fMn+ZwOJDL5WUf+isWi/T9cLvdCIVC6OrqgkQieejPSiQS2N7eLgkDljsMBgNKpRIsFgs6nQ4mk4l61IjHc2trCzweDyqVqkSWj7ShVqvVGB8fpx4nq9WKzc1NRCIRqsxRKBTQ39+P4eFh2n2IzItCoUC7apnNZuzu7lIPpUgkAo/He+pzqFgsUhkwUoDzIFXkd/oc8nclGOB3gqgn7O/vIxgMYmNjAy6XC1arlRap6XQ62o5dIBDQYquamhraTAcA7Wzp9/uxsrKCra0tBINBcLlcNDc3Y2hoiK4Z5bxu3A2SwhgOh6nNodFooFQqSyJ0wWAQJpMJwWAQwM2Upf7+fvT19aGhoQEMBgPBYBB2ux1OpxMMBgPNzc23yWI+DsraeI3H47Db7fj888/x61//GrW1teDz+bQpwePWDSs3vF4vNjc38cknn+CDDz64rTuSWCxGU1MTOjs7D81T+LggWqzpdBqxWAzBYJCGLv7whz/go48+AofDoaG8RzFeiQHX0NCAf/iHf8D09DQ+/vhjZLNZpFIp2O12fPrpp/D5fBgfHy/7Qp66uro79qonxONxCAQCKiFXU1MDsVhc0R6UB4FstpFIBGazGQ6Ho0S4/ty5c9jY2Lgtv5PICT3//PP4u7/7u7J/n7xeL9xuNz777DOYzWb88z//8yMZr4FAANevX4fZbAaAivBIM5lMqFQqyOVydHZ2wmw2w2Qy0Za3qVQKFy5cgMVioeFMAumcpVKpoFKpUFdXh7q6Oly9ehV7e3sIh8Ow2WxYWlrCRx99hNdee422U9XpdPRzcrkcotEo9vb2cOHCBQQCAeRyObDZbNTX19MW1E+TQqGAjY0NbG5uwmg0Qi6X0zSSR/msSoXoHyeTSXz00UeYn5/H5OQklck72OmStBXWaDSor6+HRCJBXV0djh8/Dr1eT6/zer04d+4cLl++jBs3btDDjE6nw/j4eNlqzD8IJGfV5/MhkUjgypUryGazePXVV9Ha2kqfy+l0YmFhgf5ef38/3nzzTYyNjUGlUiEYDGJlZQWLi4swmUzQarUYGxuDVqt97GNTlsYryVVzu924cuUKrFYrCoUCbXFKejI/q0LJmUwGuVwOOzs7mJycxM7ODu2iA3wV5jEYDDhx4gS6uroqOlQB3DQsyemsr68P8XicyqIRb/Ot1faPSj6fp4nkBxfo2tpa2jqxUrjXd04EtDOZDICbh52Ojg5asPGsQdaNcDhMPSQLCwvY3t6m1zAYDCSTSXg8Hvr/hGQyCR6PVxHh3mKxCKfTievXr8Pv999Ta/FukPGKxWKwWCw0j43P51dETjQpQjx27BhYLBbef/996hEqFouIx+NwOp1YXl6GSqWCRCKhbVAPpldIJBL09fVRtZL9/X1sbm5Scf9EIoHz589Dp9MhFotR8f5wOIwbN27gxo0biMfjEIlEOHnyJHUmPM2UNlIzkEqlsLi4iI2NDRgMBvB4vLseRkihFgmnu91uqvX7uNbaw4CkC5EW6mtrazCZTCgUCqirq6O68FarlVbER6NR2O12eDwe8Hg88Hg8uk+Q5h6Li4uYn5+nLXNJjnBbWxv4fD5qamoqcg8mikcTExO0y6fJZKJ6xel0GhKJBCKR6DaJTqIl7vf74fP5YLFY8MUXX2BjYwPFYhEajQYTExPo7u7+ZhivZPLNzc3h5z//OTweDwqFAtRqNcbGxjA4OPhMe12TySRCoRDOnj2L//7v/75NEonkmRw9ehQ//vGPoVAoyt5LdD8YDAZkMhmkUim+853voLm5GdlstkQW7HGFsHK5HNxuN/b3929Lw2hsbCz7kPGDQhZfMnfUajUGBweh0+meiee7FbJuLC4uUm/LzMzMbR6kWCyGWCx22xjEYjHU1NTcU0O5XCgUCpiensbZs2dRV1f3SA1aSJqO3W7HysoKHSeRSISmpqayP8QR43ViYgJDQ0PY2trC8vIy/bnf70c4HMZnn30Gl8uF06dPo6Ojg7ajJpAcc+JBM5vNuHjxIiKRCHw+H+x2O/7jP/4DKpUKw8PDaGxsxLFjx7C1tYV3332XKln09PTgJz/5CfR6PVpbW59qh6VisQi32w2n04nPPvsMMzMzeP311yESie66N5ACtxs3buDKlStUKmtvb++JFto8SYrFIo2kffzxx1hYWMDly5fhcrnQ2NgInU6H73znO+jr68P58+exurpK27uurKyUpM5MTU2ht7cXPB4PAoEAGxsbuHLlCvL5PBgMBgwGA86cOYOxsTEIBIKKiFjcCQaDgcHBQfB4PAQCAezu7mJ2dhbz8/MwmUzo6enBiRMnMDg4eFtq0cFUikgkgi+//BK/+MUvaEOdjo4O/PVf//UTSaEpO+O1WCzC7/fDarViZWWFehXEYjHa29sxPDwMlUr1TG6+hHg8TvN0kskkXUhImLOzsxNHjhzB4OAgpFLpobc2fVyQ71ShUMBoNEKv12Nzc5Pm4VgsFszMzECv19Nw30FPyt0gqQiJRAKhUAj7+/t0sb5VYLlSF6A7kU6n4ff7qRIBCX89q++Oz+eDzWbD9PQ0tre34XK5Sr5fgUAAiUQCoVAImUxGuyCRXGiBQACZTIbR0dGyHiOiOkGiB01NTVCr1Q9swBKPazAYxM7ODu2SI5PJoNPpYDAYIBAIKqK95cFc7r6+Ppw+fRpmsxmBQIDmBO/s7NBGLW63GwqFAmKxGGKxuKSDWDweRyQSQS6Xg0QiQW1tLQ23+3w+1NbWYmdnh4r5Ey9vc3MzXnnlFeh0OnR2dj5y4dzXoVAowOfzYXt7G36/n+b9MhgMWkRGDv/JZBLJZBJutxtutxuzs7PY2NiA0+mE2+1GIpEAi8WCQqGARqNBS0sLXWcrAfK8Ho8HOzs7YLFYqK+vx4svvgi9Xo/jx49DpVIBAAwGA410WiwW7O3tYWtrC06nE6FQCGazGTweD3w+HzabjUaxampqoFarqaJFub8n90Mmk8FgMKC1tRVarRbBYBDxeBwul4vqznu9XlgslpLfc7vd2NzchMPhgNVqpak7XC4XKpUK9fX1VObymTZeycs1PT2NX/ziF7TjlEwmg0ajwejoKN544w3w+fzDvtUnBtHvnJmZgd1uL8nVI3kpr7zyCn784x+joaEBcrm84l+cgzAYDKjVaigUCoyNjSEQCGB+fh6JRAKffvopFhYW0NPTA51Oh5dffhn9/f3g8/n33LgjkQiuXr2K9fV1nDt3Dl6vF3a7Hdlsli5GzyKkspaEg59lisUirly5gv/93//F+vr6bTq3wM2mFcPDw2hqaoLRaER7ezs6OztRU1NDDTViyJZzJIMUGEYiEYTDYbS0tGBkZOSe+c8HIR7XhYUF/OxnP6O5rt3d3Xjrrbdw/PhxiESiijnIESPzzTffxODgID744AMsLCzQVIjFxUXcuHEDn3zyCe0mVF9fj/HxcRw9erTks8gepNFo6DjV19eDx+Nhd3cXk5OTKBQKVPS/ra0Nx44dw7/8y7/QbkVPO4WLyJstLS1hamoKNputxHglhx3S/GVtbQ0rKyuYmprC7OxsiUwaGU8Oh4OhoSGcOnUKExMTEAqFFbPP5PN5pNNpmM1mLCwsoKOjA93d3fjpT3+K3t5eqs7R1dVFx65QKGBvbw9WqxXvv/8+PvzwQwQCAezt7dHnJnODtBHv6OjA0aNHn4mUPaVSCblcjomJCQSDQVy7dg07OzvY3d2F1WrF5OQkmEzmbc4es9lMlQfIQYkchMfHx6nSx5NYT8vKeCUvmNfrhdVqpeK2Wq0WIyMj6OjoqKgT4MNCXiS32421tbXb9FzlcjlUKhVaWlogl8sPpZr1aUByz3p6eqjHNBAIUG/R7u4ulW6JRCIlVaF3wm63Y2ZmBk6nE3a7nWq7kheRVAfrdDr09PRAr9dXzMZ9J7LZLHK5HLxeL4LBIFKpFIrFIvh8PhQKxTN7+Kurq0NDQwOEQiG6u7vhcDjgdruRSqWQSqXQ3t6OkZERNDU1oa2tjbZEJDnkleKZJgY2h8MBh8OhxSn3S6k52PzD4/FgZWUFVqsVmUwGMpkMLS0t6O/vR319fdmPwUEO5q4CgNFopDn0TqcTgUAAsVgMuVyOpouQNsv3GjOyESeTScRiMXA4HBiNRrDZbIjFYiiVSnR2dqKnpwdCofCuXQCfNKQ5A6mkJ57hK1eulKxjJMd1eXkZNpsNOzs78Pv9VCZLIpFAJpPR/zYajRgbG6NV5JU0J4CvxoWo1wQCAUSjUVq0Sg6rByMZXq8XyWSS7sV3SlUj71EgEIDH4wGfzwefz6fvZSVCUnC6uroQj8eptKTD4YDf7weAO7aBJbUoZM/m8/kQCATo7+/H2NjYE63HKSsrkFQHWq1WbG1t0Ulz9OhR/OQnP0FTU1NFV/TdD/JSTE1N4Z133rnNK9jR0YHx8XG6oDyrEM/X8PAwjhw5gkwmA7PZjEgkAr/fD4/Hg9nZWfz5z3+m197L2CQncbKYAShZkAQCAYxGI4aHh3H69OkH6vFczqRSKXi9XphMJrhcLvqsMpmMViA/a5A2qcePH0djYyPkcjm+/PJLTE5OYm9vD3t7exgdHcWPfvQjutkc3JAraU0hXmIipJ/NZhEKhWhB593IZDKIxWKYm5vDJ598guXlZWxtbUGpVKK7uxvDw8MYGxuriHSBW2EwGFAoFJDJZHjttdcwODhIU0fIc9rtdni9XqTTaZrL+iDGhkQigVarhV6vx9tvvw25XA6DwYD6+noYDAYqvXUYY3Ywx3NjYwOXL1+mucv/+q//in/7t38rua+DRhlJJWhvb6feyd7eXrS1taGxsZGmVVRy17VisQifz4dUKoXp6WkAN3XRZTIZDWWn02lEo1FYLBZcv34dbrf7ngVrpBB2ZWUFH374IXp7ezEwMIDa2tpHyj0vB8haODAwgP7+fvT29mJyfpt6SQAAC1VJREFUchKffvopLl68eN/f53A4EIlEUKlU6OjowKlTp/CDH/wAHA7n2TZeSTjD4/Fgd3cXdrsdhUIBDQ0NUKvV6OjooNWvlbaoPgjkdLe/v4/9/X1YrVZqbAE3C4k4HA7Vt600z8ijQhaX4eFh+Hw+2nXL7XYjGAxSTUfiabwbt56e2Ww2DfGRZgBDQ0MwGo2PpIlYbuTzeSSTyZI5xGAwqNRcuUuAPSoSiQQ9PT1UCol0jiI5WKRz2p1aDVcaDAYDfD4fUqkU4XAYFosFbrcbQqGQ6iBnMhlks1n6jng8HprjaLFYkEqlqE7j4OAg+vr6SvI8Kw1iZNXV1aFYLKK2tpZ2PGpra8P+/j5CoRC8Xu9DpdK0tLSgs7MTKpUKAwMDEAgEkMvlEIlEh+ZtPQjx+InFYigUCoTDYaRSqZIOX8S4FwqF9H6JLJTBYEBzczPa2tqg1WqhUChQV1dXse8JGQ+ZTAa1Wk2LVs1mM/2e1Go1/e58Ph+CwSAWFhZgtVrhdruRyWTAZDLB4/HQ1NQEg8FA95u9vT3YbDYavSCpbhKJpOK7fZK5oVKpMDIygmAwiJqaGphMJjgcDvqOCYVC1NXVUU3cxsZG2vG0qakJR44coXvpkxqPslilyAL7hz/8Ab/61a9ouPzUqVM4ffo0JiYm0NzcXNGT4l4Qj+t7772Hd955B06ns8RFL5PJaBeP119/vWI3l4eFeFWff/55nDx5koqIz83NYX19HXt7e7Db7YhGoyXtUe+HWCzGkSNHoNFocOTIERgMBhw7dgxcLpeGfyqZVCoFv9+PaDRa8s7weDxIpdJnNt1EpVKhoaEBHo8He3t72N/fx8LCAhQKBRoaGqBUKksKdCodpVIJjUaD7e1tuN1ucDgcmmcml8vpJru1tQWbzYb19XXMzs4imUwikUigu7sbL730Ek6fPo1XX32V5vJV8twg6QISiYRqu548eRLFYpHKxq2trWFubu6BP7Ovrw/Dw8O0TexBj/1hrxWkYI3NZqOzsxOBQABXr14tUWkh15H24STH++jRozAYDGhoaKAtTSsldeZekE6Cvb29SKfTmJychMPhwPvvvw8Wi0WbVpD9hRQnRaNRxONxmi5CVCi+//3v4/vf/z5isRhCoRA+/vhj/Nd//Rc2NzdhNpsxPj6OXC6H0dHRZ6IGhTQW0Gq16OjogMvlwrvvvov33nuPpgcMDw+jt7eX7plDQ0Po7+8Hl8uled9P+lBXFlZQMplEIBCAy+WiLTsBQCgUorm5uaJlKB4EYrz7fD54PJ6SIi3gZi/ugYEBaLXaigzpfV3IIiORSNDa2opisYi6ujp4PB74fD668ASDQXi9XqrDmEqlEIvF6KbD5XJppTnJeezp6aF5oJWq03crLBYLXC6XelhJNTbxNj+rhx+yRpA8RZLXzGaz/197d9PTxBbGAfw/hVLambbYFyudwrTQ10BLKwE1tviSGE1caFyYGOPSxA/gxzDxY+hOV8a4ZaEbV6IJkSaoKFqKlICgQdu78J6T1iv3XrwXp53+f4krqpbT6cxzznnO88Dv97d0R+p0iqIgHA4jkUhgaWlJbnvabDasr6/LoPb169dYXl5GpVLB2toaXC6XDOKz2SwKhQISiQQcDodlrv8fgy+bzSaL0tvtdui6/tP8vd2ISg5ilandiHzFiYkJAEAwGEStVmvZbbLZbMjlcjAMQ+5MxGIx+Hw+OJ1OS+3GiAArm83KQP3t27d48eIFPn78KFemRXC1tbWFL1++yNzNUCiEQCCAkZERWV7Q5/PB5XLJfPpjx45haWkJi4uLWF5exvz8PNxutzyg1On3GhF8ejwe1Ot1TE1NYXt7W65qG4aBeDwOh8MBp9OJSCQi0+1+17Vk+jex0Wjg1atXePz4MZ49e4YPHz7IL93BgwcRj8fh9XpNfpf7p9FoYG1tTRaI/lmLxmKxiKtXr3Z8F63/yu/3w+fzIZlMykMqYkt0Z2cH5XIZs7OzGBoaQjKZRLVaRblchtfrha7rGBgYwODgoAzkxE2uOaerk284gtPpRCgUkk0f3G43wuEwdF3/27qPVrG1tYU3b95gc3MTAGSOYiAQMPmd/X9EZyBd1zE/P48nT57g3r172NnZkTngIsdb/MlmsyiVShgfH8fk5CQMw5BtkM3e+t5PIpgVxeaj0eieWou3e86n+N1OnDiBUqm0a2esHz/j5kOKVtH8Oc/MzKBYLGJ1dRW1Wg23bt3Cw4cP5UJHcxUB4HtzDrfbjXPnzqFUKiGfzyMWi8mVbfFar9eLZDKJBw8e4Pbt27KLX7lcRk9PD8bGxpDP5zt6XMV793g8cLvduHLlCi5fvix/3nwtiWvod39HTA1eRe/h9+/fY2FhAZVKpWW2KFbcOvki+DdWV1fx8uXLlnIlomi/x+PB8PAw/H6/Zeq5/irx5RDBl1hxEA9pXdeRz+cRDAYRCoXgdrtbcltdLhcGBgZkD/t2fyj9quaapaI9pMjZEzNqKxMnYOv1OhRFgaZpMh/NSsSJ4Ewmg5MnT2JxcRErKysyx29gYACqqsoDamNjY/JgjpjMWb1VcDPxHLHq5K0dV4XNID5nu92ORqMBj8cjt7qbV1p/5HQ6ZYmwZDKJQCAgyzw13zNVVYWu6ygUCrhw4YJc1Rc5w+3e3GMvmgPTdludN+1qbzQasof9o0ePcOfOHVkaq5vU63XMzs7i/v37mJuba/nZ8ePHMTk5iVOnTiEcDls+6NirHw+XqKqK6J/doxRFQaPRQDqd/mmOmpUnROKAXy6Xw8zMDGKxGA4fPoyJiQnLbA3vhShpJFairUBRFDidTvT39+PatWu4dOkSnj59iufPn2NhYQHv3r1DLpdDIpGQeY2ixaPYNu6264C6i7jva5oGVVVx/fr1XVelm4lgdbeJvqZpGBkZgWEYuHjxYsv/1/x3aX+ZOlX7/Pkz1tfXsb6+jo2NjZbuFSJ3wsrbWcLW1haq1aqcDYoV51AohFQqBY/HY9nVgv+q+dpo9+Lyv4u4aQcCARQKBXmS2MrpN39HrBpY7T4iPmexOhSNRtHT0wNN06DrOtLpNAzDkKfKXS6XLF3Dhyt1i+bvyf/17/FZYz5Tg9dqtYq5uTksLy/LwsDA92LjBw4cgM/nQ19fn+VvtNvb26jVajJ4dzqd0DQN09PTOHPmjGWLytP+isfjuHnzptz26YaJYDcS7RszmQxSqZSs49n8mVsxv5GIupepweu3b99kX2FRl89ut2N0dBSpVAqGYXRF8Or1ehGJRPDp0ydsbm7C7/cjEong0KFD6O/v5wyPfonYweg2vb29UFUVqqrC7XbL+pdWzRk368AEEZFZ2urJFgwGMTg4iBs3buD8+fOyZ72VVwsURcHRo0fR29uLu3fvYmVlBadPn0axWMT4+HjHduwgMoumaYjFYkin05iensaRI0dQKBQsdZCCiKibmRq8qqqKcDiMTCaDjY0NDA8Pw+fzIZFIyDxPq68miKoC6XQa+XweOzs7yGQySCaTlu0oRrSfHA4HvF4vRkdHUalUMDIyApfLxR0MIiKLMC14VRQF0WgUQ0NDKJVK+Pr1q8zL6uvr65oSLoqiwDAMRCIRTE1NyaLq7VoQm6jdaZoGl8sFXddx9uxZWaeRE0EiImswNToSOa7dToyD1epQEplBnATmvYWIyJqU5qYA//hiRVkB8Gr/3o7pjEajEfy3L+6C8QD2MCYcj1Ycj1Ycj1Ycj1Ycj1Ycj1Ycj7/qgjHZdTz2FLwSEREREZnJ2qehiIiIiMhSGLwSERERUcdg8EpEREREHYPBKxERERF1DAavRERERNQxGLwSERERUcdg8EpEREREHYPBKxERERF1DAavRERERNQx/gD2Tr6F0e7lRAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 864x864 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     -         -         -         -         -         -         -         -         -         -    \n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x864 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     -         0         -         -         -         -         -         -         -         -    \n"
     ]
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "for i in range(10):\n",
    "\n",
    "    _, ax = plt.subplots(figsize=(12, 12),\n",
    "                         nrows=1,\n",
    "                         ncols=10,\n",
    "                         sharex='all',\n",
    "                         sharey='all')\n",
    "\n",
    "    print_line = ''\n",
    "\n",
    "    for j in range(10):\n",
    "        idx = (i + 1) * j\n",
    "\n",
    "        ax[j].imshow(test_X[idx].reshape(28, 28), cmap='Greys')\n",
    "\n",
    "        pred = predict_for_test(test_X[idx])\n",
    "        pred = '0' if pred > 0 else '-'\n",
    "\n",
    "        print_line += '     ' + pred + '    '\n",
    "\n",
    "    ax[0].set_xticks([])\n",
    "    ax[0].set_yticks([])\n",
    "    plt.show()\n",
    "\n",
    "    print(print_line)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
